# Tutorial AnyLogic: modelagem de processos

![](/files/-MSJzKPgLjG71RkQdSji)

Este é um Tutorial do **AnyLogic**, ambiente de Simulação de Eventos Discretos, Agentes e Sistemas Dinâmicos (*si desea leer la versión en español, haga* [*clic aquí*](https://tutorial.anylogicbrasil.com.br/v/tutorial-es/)). 

Este volume I foca o conteúdo de **Eventos Discretos** do AnyLogic ou, na terminologia do software: **Modelagem de Processos**. O volume II foca a Simulação de Dinâmica de Sistemas do AnyLogic e está disponível [neste link](https://tutorial-ds.anylogicbrasil.com.br/).

![Os três métodos de simulação do AnyLogic](/files/-MSKq_M0Latri4pgeD10)

O **público-alvo** contempla quem deseja uma **partida a quente** do AnyLogic: estudantes, usuários experientes de outros pacotes que pretendem migrar para uma ferramenta mais avançada e lendas do rock entediadas entre suas turnês.

Em breve, teremos tutorial para a Simulação Baseada em Agentes.

*Se você deseja um treinamento completo em AnyLogic, visite a* [*página da Genoa no Eventbrite*](https://genoa.eventbrite.com.br) *e se quiser saber mais sobre quem somos, como vivemos e respiramos, visite* [*a página da Genoa*](https://www.genoads.com.br/) *na rede mundial de computadores.*

![](/files/-MSK1Kfuh7cP5gXVFtAU)

Antes que role a pelota, tapinhas nas costas das pessoas que nos ajudaram no processo de revisão e principamente de inclusão de alguns tópicos relevantes nesse tutorial: os engenheiros João Ribas e Marcos Nogueira, o Prof. Marco A. Mesquita do depto. de Eng. de Produção da USP, além dos incasáveis (até então) estagiários da Genoa, Aline Yugui e Jonathan Carvalho.

### Como citar esta obra:

MEDINA, A. C. et al.Tutorial AnyLogic: Modelagem de Processos. 1ª edição. São Paulo: Genoa Soluções, 2020. Disponível em: <[https://tutorial.anylogicbrasil.com.br/>](https://tutorial.anylogicbrasil.com.br/>). Data de acesso: \<coloque a data>.


# Premissa

Este tutorial parte da premissa de que você já teve algum contato com a Simulação de Eventos Discretos ou mesmo a Teoria das Filas. Em momento algum o Tutorial vai explicar conceitos de modelagem ou simulação, assumindo que você já entenda o básico. Se você quiser a recomendação de [um livro bacana de Simulação, siga o link.](https://leanpub.com/msed)


# O que você precisa para este tutorial

Para realizar este Tutorial, você precisa:

1. Um computador ou notebook (64 bits) com Windows, Mac ou Linux instalado;
2. Mouse com rodinha (para o **zoom** de tela);
3. Acesso à Internet;
4. Amor no coração.&#x20;


# Etapas

Este tutorial tem quatro partes que devem levar cerca de duas horas para serem percorridas. Recomendo que você abra este arquivo em um segundo dispositivo: um outro monitor conectado ao seu computador, um Ipad ou, vá lá, na tela do celular. Não imprima este arquivo ou mesmo gere um pdf, pois ~~eu já fiz isso~~ não tem cabimento imprimir um tutorial cheio de GIFs animados.&#x20;

O Apêndice completa o tutorial com coisas específicas e de execução rápida.

![](https://lh5.googleusercontent.com/7k8w0nXmXL_hDwNMYktb87kw4GcSYr8csPr8Iu9LsOdeBPE_hFHPz-UQidrYgFK3oKsP-XUsJQqiBXH0Q5EMdyqa4t5meiBxCnhC7ifKCMyWr6gBQxdNjvO1I8bikRjr7Uk2ueHM=s0)


# Download e instalação da versão PLE

O AnyLogic possui uma versão chamada [PLE - Personal Learning Edition](https://www.anylogic.com/downloads/) - específica para auto aprendizagem ou uso em sala de aula. Se ainda não o fez, você deve baixar a versão PLE por meio deste [link](https://www.anylogic.com/downloads/) (ao final da página, você encontra os requisitos mínimos de hardware e software para executar o AnyLogic).

A instalação para **Windows, Mac ou Linux** é feita sem percalços, seguindo as instruções que aparecem na tela.

![](/files/-MSKp8h-Kiznu7VU4ysu)


# Tela de boas vindas

Quando o AnyLogic é aberto pela primeira vez, surge a tela de boas vindas, como na imagem abaixo (a cor predominante pode ser outra se a sua versão do AnyLogic for diferente, não se preocupe quanto a isso):&#x20;

![](https://lh5.googleusercontent.com/ZraQDg4oLHKHXmS3BTASZZfKYgYsnHxUrQ633hDhA3QFm10cFAoBp7vDLP1z9L5yvfmXw2myVpkSHDaWRur5o9qxztTdGj0PYbfsMsnXuMidX4_4LmLeRHk4yTwhPfqKJcw2Fz_e)


# Abrindo um modelo

Vamos começar abrindo um modelo. Clique no botão **Open examples**, localizado à esquerda na janela.

A tela muda para refletir a disponibilidade dos mais de 300 exemplos embarcados no AnyLogic, inclusive é importante que se destaque: todo usuário avançado do AnyLogic copia (=CTRL+C) ideias destes exemplos.&#x20;

Procure o modelo **Distribution Center** em  “Supply Chain and Logistics” na coluna **Examples** e, a seguir, selecione o modelo **Distribution Center** na coluna à direita ou simplesmente digite “**Distribution Center**” no espaço para digitação (na parte superior da primeira coluna).

![](https://lh6.googleusercontent.com/JWd7fbK5Cgg8cRoulLuqu16E1E-822lqB0Vt5-J4RMNO3c9ykkc2EwQi2rquX9VCx4U3Y-B9JZ6mIQEZ_gSDNuxLM4YH5vKPNOGq1Jc6XbtgCbyns7bRNSJvqiYn4rqeeH3nBYD7)

Com o modelo aberto, é fácil reconhecer as 3 grandes regiões de trabalho e comandos do AnyLogic:

* À esquerda é por onde você vai navegar pelos **agentes** do seu modelo ou buscar, na paleta, elementos/blocos de construção;
* Na região central, temos a área de trabalho propriamente dita, para onde os blocos são arrastados e o modelo é construído;
* À direita, temos a janela de **propriedades do elemento selecionado com o mouse**. Na figura a seguir, por exemplo, o objeto selecionado é o ícone com o nome do modelo **Distribution Center \[cloud]**, de modo que à direita temos as propriedades principais do modelo aberto (note que podemos modificar o seu nome ou a sua unidade de tempo, por exemplo):

![](https://lh3.googleusercontent.com/d6NGQIMR8Q2Ep9WoY-LCbU20AL2kO9-C-ZRbH50XyjHpMTDCPTFactJlj9NsWpb2z0Q_-Bk74FRS-SJ6WOTxPYMRC1AqkBHT1_sGcVEuHt1dWS1N1tnXDF7gwny-Az52kOdJ-MoU)

Para execução do modelo, primeiramente deve-se clicar no botão verde na barra de menu superior (“**Run Distribution Center**”), ou usar o atalho (F5, para Windows):

![](https://lh6.googleusercontent.com/1uXUZGjkoddNPzx5MinRl4zxo9D8cvM9sgjPIlFTi8qtT87-UoJKR4dIJxdXE4te_IMK3IAP8oK1c7RgM94hu1hmKyV0AVue5KiF7Hx1CTXRFf0HmHpMNxsssKTiyV0jBh3nvk5g)

Então, o AnyLogic compila o modelo e, se não houver nenhum erro de compilação, ele abre o modelo no seu formato **executável**.&#x20;

Importante: o AnyLogic gera modelos executáveis em linguagem Java. A versão profissional do software permite que o usuário exporte seus modelos em formato executável, de modo que eles possam ser executados em computadores que não possuam o AnyLogic instalado.

Para iniciar o experimento de simulação, utilize o botão de **Run** no ![](https://lh4.googleusercontent.com/GlGkuxTmcjW4T9kPbd9r6rGq6g2SiWAOD7qipWBiE8ZSn54zwPzD_E4jVf6P2MpZUAVKk3NllDVP4dJ02aomiy-Oemd1UWHbyBbxzRPWr6W-rlelINgxUQ9rHibogPlJQep9VgzS)canto inferior esquerdo da janela:

![](https://lh3.googleusercontent.com/KUrMjZDzHS8-wlvSeE1wsvP2F17Pis252SaAqAoPWL5VWIYsxPFVn0ByrFW7EwcSnqI9reT1TsxbbMZaRW41x0SrTGZHEvl2f94Uj9ectGE5C8Wm_VHf4p5FUaU7cAPiMuJYZkpx)

Note que a simulação do **Distribution Center** é iniciada em uma tela com visualização 3D do modelo. Isto não é uma regra do AnyLogic, mas sim uma definição da pessoa que construiu o modelo.&#x20;

Com o mouse sobre a tela de 3D, você pode navegar pelo centro de distribuição, para observar melhor a animação. Destacam-se os comandos:

* **Girando a rodinha do mouse**, você provoca o **zoom**;
* Segurando a tecla **Alt**, apertando e **segurando o botão esquerdo do mouse**, você **muda o ponto de vista da cena.**

#### Zoom: gire a rodinha do mouse:

![](https://lh4.googleusercontent.com/5PlFrUaJ7VOpfwDZxDg0vZrTWwQQKFhmhzQ3VvwGIUkfx1tRO6gvIGmXuuHTbG5VEmUJ4xw4LCmS7q7aNT_3QExL-WCn_ZeJjkwueF6BaRcrf5et6HJ-fIYeavPutpfrNvre4IfC)

#### Rotação: mantenha o botão Alt apertado, clique e segure o botão do mouse

![](https://lh6.googleusercontent.com/atR7-D8-uHq6cj-2HYbMsYAZMu5ZAsNP0Tgv2PGKjcund3CCLrwbvvfEh5LYOQjjuWfW6UgZLRAAyLkMOx_pbFooXBEYtoVb7GPGJuc7dqlnLNU1PoAwO1UeQNGaVIGVbNLWJCa5)

Note também a parte superior da janela, onde estão os botões “2D”, “Logic”, etc. Navegue por eles. Experimente, na região branca inferior da janela “3D”, os botões deslizantes que modificam alguns **parâmetros** do modelo durante a simulação, como: o número de empilhadeiras (forklifts), o número de caminhos de descarregamento por hora, etc. Mais abaixo e à esquerda, você encontra os botões típicos de navegação de vídeo (aqui é simulação!) e, no canto inferior direito, existe uma engrenagem que, se clicada, abre mais opções autoexplicativas da tela.

Para sair do app é só fechar a janela clicando no “X” do canto superior direito.


# Exercício: fila bancária

Neste tutorial, construiremos um modelo bem simples de simulação de uma agência bancária, composta de alguns caixas de atendimento pessoal e um caixa eletrônico. Começaremos pelo atendimento eletrônico, deixando a área de caixas para a Parte III do tutorial.&#x20;

Objetivo desta etapa:

* Construir um modelo de simulação que permita avaliar o nível de serviço (tamanho da fila) e a utilização do recurso (caixa eletrônico), para certa taxa de chegada de clientes e tempo médio de uso do caixa.&#x20;

Dado que:&#x20;

* A taxa de chegadas de clientes é de **2.0 clientes/min** em média e os intervalos de tempo entre chegadas sucessivas são exponencialmente distribuídos;
* Os clientes utilizam o caixa eletrônico por **0.4 minuto,** em média, sendo que a distribuição das durações destas operações também é exponencial.

Modelar uma fila bancária do tipo [M/M/1](https://pt.wikipedia.org/wiki/Fila_M/M/1) (como a deste exercício, com um caixa de atendimento e distribuições exponenciais dos intervalos de tempo que governam os processos) está para softwares de simulação, como criar um programa “[Hello World!](https://pt.wikipedia.org/wiki/Programa_Ol%C3%A1_Mundo)” está para linguagens de programação. Por ter uma modelagem simples, este exercício introdutório ajuda a formar uma primeira impressão sobre como o software de simulação será: fácil, difícil, sexy ou chato.&#x20;


# Criando um modelo

Um novo modelo no AnyLogic é criado pela opção de menu suspenso **File > New**. Informe na janela de criação o nome do modelo, Banco, e troque a unidade de tempo do modelo, de seconds para minutes.

![](https://lh5.googleusercontent.com/XiziEkZCryagRp3TVbPUPMvzg1bRPz0NbzUbjZKz0e7zuNpMYYWt9Ns6P4IqqtP1hO6gADum-009TuGqSdJu35hNLZBQx1pL-CRpukLVZZ7AoncIFLaKcDg0nfPWtuvfwTarD__d)


# Construindo o fluxo de processos do modelo

O AnyLogic possui diversas paletas com blocos de comandos que são arrastados para a área central de modelagem.

Nesta primeira etapa do exercício, construiremos uma fila M/M/1 composta, basicamente, por:

* Um processo de chegadas de clientes, com intervalos entre chegadas sucessivas exponencialmente distribuído e valor médio de **2.0 clientes/min**;
* Um processo de uso do caixa eletrônico, com duração média de **0.4 min/cliente** e distribuição exponencial, equivalente a uma taxa de atendimento de **2.5 clientes/min (= 1/0.4)**;
* Um único servidor (apenas 1 caixa eletrônico, por exemplo).

O bloco **Source** é o responsável por gerar entidades (ou, na nomenclatura do AnyLogic, gerar agentes) num fluxo de processos. Clique, segure e arraste o bloco **Source**, a partir da paleta, para o meio da tela! \[Repare, na região de **Properties** à direita, como o menu sensitivo se altera].

![](https://lh6.googleusercontent.com/0a0Sf6nZKrnswXe7dW_trQpmPwYrjCc0T2j7-3N_G8FROBIG-g1DwROC-PVn4Ad_35dVKu80F16FKFID1ALEub2WaF151XzdZUtiwx534mzJdKyHtgV5RUGTPOyc6TnqNfrCppjF)

A fila M/M/1 tem apenas um servidor, então faremos um fluxo bem simples com elementos do AnyLogic:

* Um bloco **Source** para gerar agentes;
* Um bloco **Queue** que representa a fila de espera;
* Um bloco **Delay** que representa o processo de atendimento;
* Um bloco **Sink** que finaliza o agente criado no **source**.

O “arrastar e ligar” do AnyLogic é beeeeeeeem fácil: se você aproximar o mouse do bloco, ele já cria o **conector** que representa a ligação lógica entre os blocos.

![](https://lh6.googleusercontent.com/_OeSbZ5Hdx14hOTNphHUL8PwhcMT6NppwTbTinPl0SMWXBDhMzqrDbPKL1Yp74JYrvQHuBPeL91mW-AGPOh_EKVU0Mj7vJ6TxYHy8EV2zQOpIxaZJoqMTbiTQgOR4uNOHJialwxw)

Mas, se você **apagar** ou não criar um conector automaticamente, ~~chore~~ apenas dê um duplo clique numa ponta **verde do bloco de origem e una à outra ponta verde do bloco de destino**.

![](https://lh3.googleusercontent.com/ZC0l1FVzBTI_sHhNJoF7vp5YSAJs0y4dGax6Tq_iu5RUQg_qPzpX9Dr78wdqGmKLJPBSu1H4xi0GCc8ZpKAluc9vWFZHt_2l0Azazft1NJXhjA5MqrApQJuUatYfb1GOTDRp0jvK)

&#x20;Construído o fluxo dos processos, vem a etapa de configuração das **propriedades** de cada bloco. Clique no bloco **source**:

* Altere o nome do bloco para algo mais empolgante como: **chegadas**;
* O processo de chegadas será definido por uma **Rate** (= intervalos entre chegadas exponencialmente distribuídos);
* Para este exemplo, vamos considerar que a taxa de chegadas de clientes é de **2.0 clientes/min**.

![](https://lh3.googleusercontent.com/dc9NcjL4zZ1MRw8fXeIOJqf_vNfH9nGVgo8JOxnBs7M1P5rkEgX74fadfg5MF2zitCAFw0BI1pbD89hHeDYbuTpqwWjdZ259CNxHwO92BCqP9caFlFAMp03YN1AAj1SXhU9Ip3pr)

Clicando no bloco **Queue**, você notará que a capacidade da fila está limitada a **100**. Contudo, por definição, a fila M/M/1 tem capacidade ilimitada. Assim, devemos clicar em **Maximum capacity** nas propriedades do bloco **Queue**, para que a fila seja ilimitada em capacidade:

![](https://lh5.googleusercontent.com/361nhnnNMw7R7l204lZcigIUDn6RpaYqkiFVhtV5XpvStObshOmwg1jJnZoOF6eHRJGpCIxdk1jhdF57xtOTdLvGj5mlWwSVaqqINwKvg-9RoUc5KunqeTgDOo4DAM-6nw5XtD5o)

**Importante**: no que, por default, as filas do AnyLogic nunca são criadas com capacidade infinita, mas sempre com uma capacidade limitada em 100 agentes. Caso seu valor não seja alterado para capacidade máxima e a fila extrapole sua capacidade durante a simulação, o AnyLogic apresentará uma mensagem de erro um tanto quanto espalhafatosa.

Para o bloco **Delay**, responsável por executar o processo de atendimento, vamos considerar que a taxa média de atendimento é de **2.5 clientes/min,** com distribuição exponencial.&#x20;

Para facilitar o processo de preenchimento de distribuições probabilísticas, o AnyLogic tem uma ferramenta específica para a  seleção de distribuições, o **Choose Probability Distributions**:

* Selecione o bloco **Delay** e a seguir o campo **Delay time**;
* Quando um campo que permite receber **distribuições de probabilidades** é aberto, ele ativa um botão na barra de comandos do AnyLogic (um jotinha com uma varinha de mágico):&#x20;

![](https://lh5.googleusercontent.com/tkiGPCUn6Bwdzet6q5DQYO4Q7TuyBKUzpjgrs_tdaie09Tc_aKOJ_HpyHsIPL-zzc_1HajPG-5T3ehoMDCjrK4V0mqXYmbEg4ja6Q2O6FuWLim4E01tP3E5W-ATg11nGYe-NWC6c)

* Clique no botão para surgir o **Choose Probability Distributions**:

![](https://lh6.googleusercontent.com/Xs1krZezphZoDeMGt24sAHhx7l-x_fNJlIznV1cfQMa_huCVMcFN35mk6ElKeiHQVrqKl-SqrjGQH9oTYjYrQqxYQlEtC8Zbpv56gGd6CSXQNGu4DPs5mXBFKjjjpPTNFXnFZ-t7)

Muitas distribuições, hein?&#x20;

**Importante**: o AnyLogic considera o parâmetro lambda ou taxa de ocorrência do fenômeno da distribuição (como usualmente fazem os livros de estatística). Por este motivo, devemos informar ao AnyLogic a taxa média atendimento de **2.5 clientes/min** (que é basicamente o inverso do tempo médio de atendimento, e, se você quiser, pode digitar diretamente assim: 1/0.4).

Pronto!

Pronto?

**Simule!**&#x20;

![](/files/-MG-V6A9SRhExSRqZtJN)

Sim, agora é executar o seu modelo primeiro modelo no AnyLogic utilizando o **botão verde** da barra de menu superior:

![](https://lh3.googleusercontent.com/QLRkB-LXjLzy8uScbUPkVubTZVkoOD1JvKDISvdv5QGlbudPCi4llmmDpXiv5GIaF8jdh7Xw2PyV_5xikk0c5eKstvhZv67XylJMrhRvyP0ITYKnJ3E1YFw2rhyVyC7SceAAdcV9)

Note que o AnyLogic executou seu modelo como um **aplicativo Java** e isto é **importante: o AnyLogic é um construtor de aplicativos de simulação.**

Na versão **Profissional** - e apenas nela - existe a opção de se exportar esse app, gerando um arquivo executável **independente do AnyLogic**, que você pode distribuir para terceiros ou executar em máquinas que sequer possuam o AnyLogic instalado.

Quando você clica no botão **Run**, a mágica acontece. Note que o bloco do **queue** ganha um preenchimento **azul escuro** conforme mais clientes aguardam na fila.

![](https://lh3.googleusercontent.com/3e2W5qboC7wT4Ai6uiuKU87Snp0rODpKfutSb3NiRmk9Xv1Z6RqogHO_dyHh-jDOYTI5janujtX1b0ICj6Nx2gcY1TIUq8BtSmDBEid2mPvuUtaBNPqWV8MPpdHB8CmPznHBPsxe)

Clique nos blocos azuis, eles são cheios de surpresas:

![](https://lh3.googleusercontent.com/nxQohE1G4Jiy4vrbfff2_srZjjNsj_qDXGJX4VUvBnRn032dXDU3iMpnaVO0QQhedlDljfYX60GqgjFO_7T6J75oLZrr28Do6s-dwDp5G9KDwIbVXC9sBz3tMOVqjEB0EQrQVtTB)

Se você simular por um tempo muito longo, em algum momento **o limite de 50.000 agentes da versão PLE** será ultrapassado e o AnyLogic apresentará uma tela branca, informando o erro.&#x20;

Para evitar este tipo de erro (não que ele vá ocorrer muito, já que 50.000 agentes é muita coisa), podemos configurar melhor o nosso **Experimento de Simulação**.&#x20;

Usando a tela da esquerda, selecione a aba **Projects**. Você visualizará um navegador com ícones empilhados, como pastas: os botões vermelhos com o símbolo de um bonequinho representam **Agentes**; e o ícone azul com um xis, lembrando um distintivo dos *x-men*, representa um **Experimento**.

![](https://lh6.googleusercontent.com/DJ7K06J2QtJac6NOKi2VZ_Uj1IaZzDyVQQDh1o1Rlblqkp3bO92LyDLuAEL0DRWIUILWhc6lJIpcr-hy-yAXYe3_IyY_-3ygYS9mAjXVh0nn_uVJNqDlM3uR7-cza41r0CtSDb6s)


# O que é um experimento?

Cada **Experimento** armazena a configuração a ser usada em uma simulação e você  pode criar, para um mesmo modelo, quantos experimentos quiser. Ao criar um experimento, o usuário pode criar uma tela de boas vindas para o usuário e definir valores para parâmetros importantes para a simulação, como:&#x20;

* O tempo de duração da simulação;
* O número de replicações;
* A semente de número aleatórios;
* O tipo de experimento, explicado a seguir.

A versão **PLE** permite a construção de 3 tipos de experimento:

* **Simulation** (default do AnyLogic), que executa a simulação com animação gráfica. Note que você **não** tem controle de replicações neste tipo de **Experimento**;
* **Parameters Variation** que permite simular diversas rodadas do mesmo modelo variando um (ou mais) parâmetro(s) (neste exercício, um experimento deste tipo poderia executar a simulação do banco para 1, 2, 3,... até 10 caixas de atendimento, por exemplo). Além disso, o **Parameters Variation** permite limitar o número de replicações, que pode ser pré-definido por você, ou identificado pelo próprio AnyLogic, de maneira a atingir o intervalo de confiança que você tenha especificado na definição do experimento;
* [**Otimização,**](https://youtu.be/3pM30wQfxV8) com configuração de função objetivo e restrições (construídas a partir dos parâmetros do modelo). [Veja o vídeo how to.](https://youtu.be/3pM30wQfxV8)

Outros tipos de experimento, não disponíveis na versão PLE, são: [Calibração,](https://help.anylogic.com/index.jsp?topic=%2Fcom.anylogic.help%2Fhtml%2Fexperiments%2FCalibration+Experiment.html) [Monte Carlo](https://help.anylogic.com/index.jsp?topic=%2Fcom.anylogic.help%2Fhtml%2Fexperiments%2FMonte+Carlo+Experiment.html) e [Machine Learning](https://help.anylogic.com/topic/com.anylogic.help/html/experiments/rl-experiment.html?cp=0_11_8) e [Custom](https://help.anylogic.com/topic/com.anylogic.help/html/experiments/custom-experiment.html?cp=0_11_9), este último permite a combinação de diferentes tipos de experimentos.

Neste exemplo, vamos definir a duração da simulação em **600 minutos** e isso é bem simples na janela de propriedades do **Experimento**:

![](https://lh4.googleusercontent.com/er_Wh1q8Ywc07B9oBhmecJQg7wt4E_KnLM19GmhppmF1nDelPNWkhtu9eNFcFLiQJUjiwB2fn9_I39BqJGNV1Vn00Zq7b3RzhWN8oVVZp7-HvmhKdM_SSfFfVCQATD5SDiezkXka)

Execute e note como o experimento agora termina no tempo determinado.&#x20;

Antes de concluirmos, se você retornar a atenção para a janela à esquerda, deve notar que o nome do modelo está com um asterisco ao lado, indicando que seu modelo ainda não foi salvo. Para salvá-lo, selecione o nome do arquivo e clique no ícone do *disquete*.

\[E se acabar a luz? ~~Chore~~ O AnyLogic tem um salvamento automático temporizado!]

![](https://lh3.googleusercontent.com/AUgjvfA_8vJCsvvujo6MgcolSO7vA0XRbCcMFvZlueiZH7pEpEPkBDFMMuxZaC1LRYrwkvrzYOcUqmoEKZ-Wz6vTmJMsG-G971sGPX_zL804sfT5-H9sh3X5-0naBy5PLsx7Eh-O)

**Importante**: com o intuito de deixar o Tutorial rápido, empurramos a animação de processos para o Apêndice. Contudo, no AnyLogic, a construção da animação é praticamente simultânea, pois em quase todo bloco existe um campo **Location** (na imagem do bloco **Source**, por exemplo, temos o **Location of arrival**):

![](https://lh4.googleusercontent.com/bEVGSqt1xEtgyi6qCboRkT-aB_fLAI6LROrOQ6BfgQHPzIuIuA43RJZE48ZVgAYufzma8lSN9PDRAkpOHpMC7jfEvtDggmxQVXoV7Eax9TImXNn0UsX-efmTZWEWDxvbPYRaQxxF)

Se estiver ansioso para saber como animar sua simulação, confira a sessão [Animação](https://docs.google.com/document/d/11TA-UShhCLIO8rlF8w18y8O_lF7YqrT6VFsnvlDTvOg/edit#heading=h.ov3rjhkkqd83) no Apêndice deste tutorial.

Se chegou até aqui, parabéns: você fez seu primeiro modelo no AnyLogic!

Fácil, hein?&#x20;


# Criando resultados de saída da simulação

No momento, o nosso modelo ainda não permite análises do sistema simulado, pois não criamos nenhuma saída de simulação. Inicialmente, vamos acrescentar duas saídas importantes para avaliar o nível de serviço e o uso dos recursos:

* O número médio de clientes em fila;
* A ocupação do caixa de atendimento.

Para cada saída, utilizaremos um bloco **Output**, existente na Paleta **Analysis**. O bloco **Output** armazena um único valor numérico e mostra este valor ao final da simulação ou mesmo, se o usuário desejar, durante a própria simulação.&#x20;

Começando pelo número médio de clientes, crie um bloco Output específico para este fim, **mediaClientesFila**:

![](https://lh5.googleusercontent.com/3K8vaLH-NRM3HIcLl4iaI4fO5jMTUMS2tJN1iHsRdwBVPdpSp_hOCise0xJcZyiN0xiaFCvSHn7hD29sbosKtrUfA7AOEKqRq0RuAokxK6IZ8tk964mZSL7Xs9q6sXJMYTiTxHnJ)

O bloco **Queue** (e praticamente qualquer bloco do AnyLogic) já vem embarcado com diversas funções pré-definidas. O que faremos, então, é acessar uma dessas funções por meio do bloco de Output, vinculando os dois. Para isto:

* Dentro do campo **Value** do bloco **Output** escreva o nome do bloco ou elemento do modelo que deseja (neste caso, “**queue**”), seguido de um “. “;
* A seguir, dispare nervosamente as teclas:

![](https://lh5.googleusercontent.com/kAgQrQGinqC2GIYPGt5z2L40O2wNV5RmGbAlT2hKgyj72bKSeVcimHDrAjYIvc-6nBKlvyhv7lXBvW9X5RjBeiaFJZgKR7KQKyxyWQF6ZEmvpSjqp0cvIYl3kCRG60OuNiCsonCo)

Por exemplo, queremos o tempo médio de espera dos clientes no bloco **queue**, assim, digite no campo **Value** o texto **queue** seguido do “.” e bata **Crtl+Espaço**:

![](https://lh5.googleusercontent.com/D6Fylm5THYB2DC-rCaZxHCTF6x3iWia0FqS96b51gShNp5I5DDXNHJSEO9UnP0GvhJoafoVbXh-cwhmQzLbgpb98z10ePL-uRhr5UZE6_Q2iS38bN5JpWm-PpRRWl32YgjrCChIE)

O comando **Ctrl+Espaço** faz uma busca em tudo que existe dentro do objeto. Digite somente “**stat**” (sem aspas) e o AnyLogic vai limitar a busca às “coisas” que possuem **stat** no nome:

![](https://lh4.googleusercontent.com/HevTxLwmWmlqYCPkaQ6GGLAW_lREfiz3B1YUngjIC6bbfTRuijhleWHeKozQKtfh_SRyUQO5MoBFNSwZI1JcQs4e3voTXgvpfyyVpQLSLSeZaR9CsSh-7UngSSTXEiQMVSal20M7)

Estamos interessados na função **statsSize** que coleta as estatísticas de tamanho de fila. A seguir, digite novamente o “.” seguindo de “**mea**”, pois queremos a média (**mean**) de clientes em fila, e dispare mais uma vez **Ctrl + Espaço**:

![](https://lh4.googleusercontent.com/s6qo_hzTxr7qGLNS2-k98g-9sTEoZJdwUWyNM3p0wD9wH9KREnThbaO9iDgGudK0xqiLhcjauYLPUpVTclpuZ4hBmwplpDTwj9khC1qaFteQyHSFXJzL97zhi7oysEM-Y_Lny4Kc)

Você deve ter notado duas opções do método **mean**:

* **mean()**:  que calcula a média do número de elementos em fila e
* **mean(time):** que calcula a média do número de elementos em fila em um dado tempo fornecido da simulação (por exemplo: **mean(100),** retorna a média de elementos em fila no instante 100 minutos da simulação.

O mais curioso é que o AnyLogic (e isso é uma herança do Java) permite que se construam funções diferentes com nomes iguais, mas com parâmetros de entrada diferentes, a chamada [sobrecarga de método.](https://pt.wikipedia.org/wiki/Sobrecarga_de_m%C3%A9todo) No caso do **Output** anterior, existem duas funções com o mesmo nome **mean**, que se diferenciam por uma não receber parâmetros de entrada e outra receber um número em ponto flutuante, time como parâmetro.

Quando você precisar pesquisar as funções de um dado bloco ou elemento, chore use a excelente documentação o AnyLogic possui uma no seu [**Help**.](https://help.anylogic.com/index.jsp) Excelente mesmo. Por exemplo, [neste link ](https://help.anylogic.com/index.jsp?topic=%2Fcom.anylogic.help%2Fhtml%2Fprocessmodeling%2Fqueue.html\&resultof=%22%71%75%65%75%65%22%20)você acessa todas as opções do bloco **Queue**.

Simule e veja o resultado. Ao final da simulação (e apenas ao final mesmo) surge o valor da média de clientes em fila: **1.823**, no bloco **mediaClientesFila** criado (note que o seu resultado pode ser diferente caso a sua versão seja diferente da minha, que é a 8.6 neste tutorial).&#x20;

![](https://lh6.googleusercontent.com/o3E2mGOuI7QnubKNEM4BvjxlEOKZeTp2kauKKSG0b8kTeVKuLb_kbl2ApiYEOe2XLS-aEK3_24sms-eP4gcYnhZ6XwNIFc2mL3MVK3qGPGwsAA55v0ZDYZbJoE2d75btZmrUYX9D)


# Comando de cópia de elementos Ctrl+arraste do elemento

Vamos acrescentar um segundo bloco **Output** para coletar a ocupação do caixa eletrônico, utilizando a opção de **cópia rápida** de elementos de tela. Basta **segurar o botão de Ctrl** enquanto você **arrasta o elemento** a ser copiado:

![](https://lh5.googleusercontent.com/pNKI3vqYZhNFpNHlhs7IG7ef0kAAxsn7ssmA5SKEW4hpnrA3sUT7NKXZ_tfCHVk2aT6QvCq77_YcC6WEIJSxc2XeQ810zx8V-PtkpJ15HxkWmhhhJq5rSbnLl27hGSl8FvCcgpZ1)

Dentro do bloco **Delay** existe uma variável que armazena a ocupação do bloco, a **statUtilization**. A partir do que você já conhece sobre o mágico e nervoso **Ctrl+Espaço**, conclua o preenchimento do bloco:

![](https://lh5.googleusercontent.com/U9tzr6TVOxyi7Kw2coZPzN3S2iGjuylELNEqMdHfGQiHEvxW4r-8xorhY6In6re91mzPDcqXz9J-IV1c4mIiYV9c1uPI9NfvTHIQnkrpDFV5ypc7AxkyBKf6huXaSAHGvKht1XeO)

Agora, dedos cruzados e...

![](/files/-MG-YeUCL_0Pk468iB-Q)

**Simule!**&#x20;

![](https://lh6.googleusercontent.com/5WKNKaRR3f8R8Q8e-0jrx1FyOqtE2p0sJTHwCdF9l2riQYkcGoLqPNur8zfheLWajoXFW9RbRu5KDd7fwYxD_mTJOPdw4j7ixXO3gCCHyAmP5M9LNQENDRJOpfXsuJIcgkdnHyAN)

Se você chegou até aqui, merece quase parabéns. Não pare, *Go, Johnny, go, go!*


# Semente do gerador de números aleatórios

Se você seguiu exatamente os passos sugeridos até aqui, nossos resultados devem ser iguais, mesmo considerando que existem duas distribuições aleatórias em jogo. A razão disso é que utilizamos (eu e você, jovem *Padawan*) a mesma semente de números aleatórios.&#x20;

![](https://lh4.googleusercontent.com/XOEYnGvALswqn7VAhxaVlRXbJ-8OaM69AuhG4f7yvNpnizrKu6MbaaiE35BzbofE1_byckjsgi4HDr7OiK0fQqV_KF8THY2nVQAv8exZ4OSAr5lNHRDb9aoW8BCRDw9vvTgRp_gI)

Lembra onde ficam as configurações necessárias à simulação? Pois então, se quiser verificar a forma de geração dos números aleatórios, vá até as propriedades do seu experimento e abra o menu **Randomness**.

Se você quiser saber um pouco mais sobre experimentos reprodutíveis (com semente fixa) ou com experimentos únicos (com semente aleatória), tenho um [ótimo vídeo no YouTube para você.](https://www.youtube.com/watch?v=m96PLSEIALg\&list=PLUJJN9tmVTj1czFMt9IKi6wge9GnmMTN3)


# Um novo fluxo de processos no modelo

Nesta Parte III, acrescentaremos o serviço de atendimento pessoal à nossa agência bancária. O objetivo aqui é:

* Identificar se **3 caixas de atendimento presencial são suficientes para atender a demanda**.&#x20;

A taxa de chegada de clientes na agência é a mesma da etapa anterior, mas alguns destes clientes preferem o atendimento presencial. Os parâmetros de entrada utilizados nesta etapa do exercício são:

* 40% dos clientes preferem o atendimento no caixa eletrônico;
* O restante (60%) é atendido por um dos **3 caixas disponíveis**;&#x20;
* A duração média de atendimento presencial é de **5 min** (em cada caixa), e a distribuição das durações também é exponencial.

A novidade nesta etapa do exercício é, além do processo de decisão do cliente quanto ao tipo de serviço desejado, a existência de 3 caixas que prestam o mesmo serviço (diferentemente da Parte II do tutorial, em que a fila bancária é atendida por um único caixa eletrônico). Usualmente, a representação de caixas de atendimento é feita por **Recursos** ou, na nomenclatura do AnyLogic, **Resource Pool**, pelos motivos que esclareço a seguir.

Quando se modela algum recurso escasso do sistema por meio do bloco **Resource Pool**, o AnyLogic encarrega-se da lógica de ocupar e desocupar o recurso, da coleta de estatísticas de ocupação e da geração de paralisações por quebras e/ou manutenções. Para aqueles já familiarizados com a simulação de agentes, o AnyLogic ainda permite configurar o **Resource Pool** como um **Agente** criado pelo usuário - com esta abordagem, o céu é o limite.

Um **Resource Pool** pode ser selecionado e ocupado pelo bloco **Seize** e liberado pelo bloco **Release**, ou isso tudo pode ser feito de maneira compacta pelo bloco Service, que já incorpora a sequência **Seize-Delay-Release** num único bloco.&#x20;

Com o tempo, você vai notar que muitos blocos do AnyLogic são mera junção de outros ou mesmo herdeiros de outros blocos. Note, por exemplo, a similaridade entre os blocos da **Process Modeling Library** com os blocos da **Pedestrian Library** (biblioteca de pedestres):

![](https://lh4.googleusercontent.com/2i0ph2TuMv3DWk9xmAn3E6tNJ_bkA7qF0_lvc7KbwSv-7fuN8lsQwOJylw9dBfemLngWzWRKy3hBBQnG5CsXLFhEUGrw179kJL_iVbYAC1rK12oOAjTtI7ax5Sdxk1YSBrHAekFt)

Antes de começarmos, vamos abrir um espaço nos blocos, caso contrário ficará difícil visualizar alguma coisa (clique e arraste com o mouse a seleção de objetos):

![](https://lh3.googleusercontent.com/MrtWxEz5MGFZrD2B8ReqTylED4mAIzRc9cOrZJvg8E7WBRTUTXFES1iwmCqxcZp3puPKVi6ChSxQIUmj60a_5T70442KeBKanO7Pg-ya-qZU8hNufaGoopphv-olOuNWESPhDwo_)

Quando um cliente entra no banco, deve decidir se vai ao caixa eletrônico ou aos caixas normais. O bloco **Select Output** representa o processo de tomada de decisão:

![](https://lh3.googleusercontent.com/oSoLXVFdXmHZeDMmeNXpZ5hpL_34I4IZ5wE05COupCmia9WXz4nqwDYqY-PzwXj1lZgU3rx5t74IvW_8nNDhLqcFIwctezixH4L_I5rJc-uvKVVAXyUqZNcyVBT8R0IS-SWQDOz7)

Agora vamos representar o processo de atendimento dos caixas normais. Um modo compacto de fazer isso é utilizar o bloco **Service.**

O bloco **Service** possui as regras de ocupação e desocupação do **Resource Pool** (caixas) ou, em termos mais comuns para quem profissionais de simulação, o bloco é uma sequência "*Entrar em Fila-Ocupar Recurso-Passar o tempo de Processo-Desocupar Recurso*" (**Queue-Size-Delay-Release)**. Lembre-se de conectá-lo ao fluxo de clientes:

![](https://lh4.googleusercontent.com/dMp2JPSYCLF4F7Eo8kFLyWWGXTb-_N1hdSqR7m3YjDCwzL0DWkKZQD9jlpqYdD1B3yLEZ1aBC5MFFTPwJrZaIphAoQ8S20kJRN2NZIt3AxTyIaD8W_yN8a5U4O2LWDsuvxOLmSOG)

Não esqueça de preencher as propriedades do **selectOutput**: 40% dos clientes se dirigem ao caixa eletrônico:

![](https://lh3.googleusercontent.com/c3FOVwm-guLJi2XBkQTxE4TgJPs6gC6nw_ATAnT6lpD2z5Jw8_z80YXIrVpyuOZ-LDbR_aVf9c-Y2KdvjwMQpYpRdPuDG5bnAHPdx_rdok2dVj71Kz0hGsPW5Noj9mkEIRkxRM18)

{% hint style="success" %}
**Dica**

Além do bloco **Select Output,** que permite apenas duas saídas, o AnyLogic possui o **Select Output5,** que permite até 5 saídas. Você precisa mais do que 5 saídas ou mesmo os conectores ficaram confusos e embaralhados? Neste caso, o AnyLogic tem um comando bem legal e genérico explicado [aqui](https://help.anylogic.com/topic/com.anylogic.help/html/processmodeling/selectoutputin.html?cp=2_0_1_37_1).
{% endhint %}


# Resource Pool: criando recursos

Os caixas são criados por meio do bloco **Resource Pool** (um bloco com o ícone de dois soldadinhos em posição de continência). Crie o recurso e nomeie-o **caixasDeAtendimento**:

![](https://lh3.googleusercontent.com/eUkSPcOLoqqSLDK-PkdnGIqCt7IGBQ7GdeXPR0zVzW9d5myT6fiNpOhsDEQfcw6mvcJk2aMn1XKRznV_VYhyO7w2mMwFkppz-fr2CdAvzb27YLLyXcnW4_aB8wypYITkxrpIArRF)

Quando um cliente entra no bloco **service**, ele deve ocupar um dos **Resource Pool.** Informe ao bloco **service**, quem são os recursos que devem ser ocupados, adicionando o **Resource Pool** **caixasDeAtendimento** na opção **Resource sets** (utilize o botão verde “**+**” ):&#x20;

![](https://lh4.googleusercontent.com/0Ij4tWsPWc2SXMU6XEefjM3tKnGHfGf_PF1oJxN1EkzSR2_tC-KU6xmvsd47ZEE5Hb-ciJDu-_8pSNnWsfuJVs07Sn0_c1RsDSQ5L-YKijLoljh1vwFrIcuKy5im8Kfmly7k7Iu_)

O passo seguinte é garantir que a fila nos caixas tenha capacidade ilimitada e que o processo de atendimentos tenha taxa média de **0,2 clientes/min (ou 1/5,0 clientes/min)**, com tempos exponencialmente distribuídos:

![](https://lh5.googleusercontent.com/zkEM4-mvLPh12t-na_smI-3VW4ZgT0g1cdAvixEv7Bb9AnusfjFFQPOzqRJUAVbERB1FLqdNwGpLmqU7EF4e0gEH6DJYNfaMJwRB31BRl87-_MLVIVACjzDw9iD48OaCJWAD-Ibf)

{% hint style="info" %}
Você não se esqueceu de selecionar a opção **Maximum queue capacity**, não é mesmo?&#x20;
{% endhint %}

Você também poderia digitar no parâmetro **Delay time**:&#x20;

`exponential(1/5.0)`

{% hint style="info" %}
Note, na expressão anterior, o denominador foi digitado *explicitamente* em ponto flutuante “5.0” (ao invés de “5”, que é interpretado como variável inteira). No AnyLogic, se tanto o numerador como o denominador de uma divisão forem inteiros, então o resultado também será inteiro. Isto porque, na linguagem de programação usada pelo AnyLogic (Java), a divisão entre dois números inteiros retorna apenas a parte inteira do resultado, descartando o resto da divisão, caso haja.&#x20;

Por outro lado, **basta que um dos números seja em formato de ponto flutuante**, que a divisão será em ponto flutuante. Por exemplo, para o AnyLogic, valem os seguintes resultados de divisão:

* `1/5  = 0`
* `1/5.0 = 0.2`
* `1.0/5.0 = 0.2`
* `1.0/5 = 0.2`

Para quem tem ainda pouco contato com codificação, isto pode parecer estranho à primeira vista, mas a divisão inteira é algo que tem lá suas aplicações e são bem úteis.
{% endhint %}


# Parâmetros

Existe um parâmetro de *entrada* claro neste modelo: o número de caixas normais abertos. No AnyLogic, **parâmetros** se equivalem a **variáveis**, mas com uma diferença: elas são utilizadas automaticamente para interface de entrada do modelo (ou mesmo de agentes, funções etc.). Isto ficará mais claro em breve, por enquanto, vamos criar um **parâmetro** de nome **numCaixas**. A criação de **parâmetros** é feita diretamente pelo elemento **Parameter** da Paleta **Agent**:

![](https://lh5.googleusercontent.com/BzoKazPzScNMkBkuI8mZUb-908rLW0wb4DmlEkDgHRsqLATcFhM1Ncc2LNX5ItfKdD6BPFiDKudaH3uRzi2nrNAsnaXtIYdPmEn-QmMkWP7JgnI460rW7jr7vxj8xghMZw_t0Byk)

Não se esqueça de definir o tipo como **inteiro (int)** e atribuir o valor 3 ao número de caixas **default**:

![](https://lh3.googleusercontent.com/1NPiPLUiTsYZ_-T8rI4dlepdd0Rg2-t-NS7Hr7ofjqUibvIgvDQtpND7drKiNcJVe_qra2NwffTmtlDopDurXMj-ok4jQqBs2WnU-nx808w_g7ojjb4w-oR6xHvCqJwUBGcx3Eyt)

Este parâmetro, que eu nomeei **numCaixas**, definirá a capacidade do **Resource Pool** e, por conseguinte, representará o número de caixas disponível. Para vincular o bloquinho com o parâmetro, vá até a caixa **Capacity**  do **Resource Pool**, digite **num** e, a seguir, aperte *fast & furious* **Ctrl+espaço**:

![](https://lh6.googleusercontent.com/IQtJ3VE0oGNfKdCG2MUQ6uI60Ok5X4iMgp3kSZJgJftHD5iBDlk1td1OoDyIJh4LtuRwknnt2g9roun8m0gFuQy1n3Q4oQmLBFvDewxN3P-X4IW38VcD_W-Zqg8fyahYG1MsrSUe)

Agora podemos ter uma ideia mais clara sobre a utilidade de um parâmetro no AnyLogic: se você for ao experimento **Simulation**, vai notar que o **parâmetro numCaixas** aparece automaticamente como **parâmetro de interface do modelo** (abra a aba **Parameters**, na área de **Properties**, tela do lado esquerdo):

![](https://lh6.googleusercontent.com/JtoMLHIjfy3nmzmLJ6LuPtGKzkxmhXl2sKXyHG3i2CyLgwdzcQXQl1pqoFt16p9jrvKfENhW4bBF_YVXQw6tKe8VWpymHShWsgVwAVAlVfHm2Chk-iINMhRQCUEWud17_moZhCf3)

Se você alterar o valor do parâmetro nesta caixinha, o experimento de simulação usará este novo valor! Ou seja, o AnyLogic criou automaticamente para você uma simples interface de dados do seu modelo. Dê seu muito obrigado ao **Mr. AnyLogic!**


# Coleta de resultados da simulação: tempo de permanência no sistema

Neste exercício, o nível de serviço que interessa ao gerente do banco é o tempo médio que os clientes ficam dentro da agência, considerando tanto o tempo em fila como a própria duração do atendimento. Além disso, ele deseja saber se a agência ficará muito cheia, ao longo do período simulado.

Os blocos **Time Measure Start** e **Time Measure End**, com ícones semelhantes a um cronômetro, são específicos para coletar dados de intervalos de tempos durante a simulação.&#x20;

Queremos o tempo que o cliente permanece no sistema, então colocamos um bloco **Time Measure Start** no ponto de início (no ponto de disparo do cronômetro):

![](https://lh3.googleusercontent.com/LwN-K0Iu2JhirOr-Kfk9EVZC1yYenKgwmXDh4OR_NTUpZIPp91ZLLUrO-B6m9O9ClnI5TvCP67ZrdZgOkY935g5Ni3kSpMav5Ihw6Ql4O13gIlIO6Jhbi80WJd9uXis1jzf0ze9Z)

O segundo cronômetro, agora com o bloco **Time Measure End**, é colocado próximo à saída (onde o cronômetro é fechado):

![](https://lh4.googleusercontent.com/5dVLjEuIFCl6O3KvunEE8ncw8NyDhihCVI-8g3DpAmGZ8cIJXmdvtoWEtG4JX3uqd_kQKog7CJk34nRFOWv6luYVbVdMjbQJ5EPdILLnRQTFNv8sMUVfJ7dIebvGCF6Gz37_esvd)

**Importante**: atenção à maneira como o AnyLogic criou as conexões entre os blocos. Ele, de fato, não quebrou as duas conexões existentes na região do **timeMeasureEnd**. Você mesmo deve quebrar uma delas à mão. Confira comigo no replay:

![](https://lh6.googleusercontent.com/9SDZ1vXtnXU7xwte-0-nEzoJW6IOIIKbF7tFcOJqzgBtGOgXwEZfH5aSFqg1b5ZuOuTdkmqdpWfgx3K0Jt0dKwLfsWtevjDS3mS9-6EPlkN9L40ksoXplSQfWjOTdiDZMuJlq2mJ)

A última etapa é informar ao **timeMeasureEnd** quem disparou o cronômetro, no caso o **timeMeasureStart** (note que podemos ter diversos pontos de disparo e fechamento do cronômetro em um mesmo modelo):

![](https://lh4.googleusercontent.com/o_NvhjtPGkIK9MAy4zk9SJ2-2FokADIuWakqzmbGA1Y_ZPRF0S7wat46SH-ghdXDFjBx953Ypahtih9usiOTNq6X0dYkxkNBU9HVdNXAIsOaNLDywMbNB_oK0Otk2f4RKzaz1Zl8)

**Importante**: dentro do bloco, eu aumentei o parâmetro **Dataset capacity** para 1.000. Para o AnyLogic, um [**Dataset**](https://help.anylogic.com/index.jsp?topic=%2Fcom.anylogic.help%2Fhtml%2Fanalysis%2Fdata-set.html) é uma **amostra de dados coletados** do modelo, semelhante, por exemplo, aos dados coletados por pesquisadores de campo do DataFolha ou do Ibope: não é feita uma consulta da população inteira, mas de um subconjunto da população. Por default (e isso pode ser modificado facilmente) um **Dataset** tem um parâmetro **x** que é o tempo decorrido desde o início da simulação, ou seja, o instante em que o dado é coletado, e um parâmetro  **y** que é o valor efetivamente coletado.

Como informei ao AnyLogic que o **Dataset** tem capacidade de 1.000 dados, quando este limite for atingido e um novo valor for coletado, o AnyLogic descartará o primeiro valor coletado na amostra e colocará o novo valor ao final na fila. Isto significa também, que as estatísticas (média, desvios etc.) serão sempre estimadas a partir da amostra destes últimos 1.000 valores.

**Dica**: quer saber mais sobre como extrair estatísticas de tempos dentro de um modelo? Eu tenho um [ótimo videozinho no YouTube!](https://www.youtube.com/watch?v=JcFqegObRK8\&list=PLUJJN9tmVTj1czFMt9IKi6wge9GnmMTN3\&index=6)


# Variáveis no AnyLogic

Vamos utilizar uma variável que permita a contagem do número de clientes que estão na agência em qualquer momento da simulação. Para isto, toda vez que um cliente passar pelo bloco **timeMeasureStart** a variável será incrementada e, quando algum cliente passar pelo **timeMeasureEnd**, a variável será decrementada.

A criação de variáveis de diversos tipos é um dos muitos pontos fortes do AnyLogic (e aqui, se você conhece Java, valem todas as possibilidades). Crie uma variável chamada **numClientesSistema** do tipo **int** (inteiro):

![](https://lh3.googleusercontent.com/kjlYmu3Qo9Z1Vu19XSebxdcnestAdi9sXUuutADB2WWvSjjigMyvN9jgjt6dIV5dZe0oiqpEBQLjQZCrsFTnfSeTIsQBnR2CifTTMrvLK5phtd12mnOOMyszDCyoBWLfEKfRoA98)

Não se preocupe com o **Initial Value** para primitivos (**int**, **double**, **long** etc.): é sempre 0 (e para o **boolean** é sempre **false**).

A seguir, retorne ao bloco **timeMeasureStart**. Repare a caixa de diálogo **Action**, ela tem uma sequência de linhas paralelas, semelhante ao primeiro hexagrama do [I Ching](https://en.wikipedia.org/wiki/I_Ching) (“O Criativo”:  ”promove sublime sucesso, favorecendo através da perseverança”):

![](https://lh6.googleusercontent.com/nCRSMXSJcRNUMZsPw9jopyh2IEISr4_imzBs_kIDEQpStVfoh11I5hxNczzSxrJy0D0BAMbui8ZqOd8pzt8B_u1UaLyA2pA44i5LeA_o6UdERvN8U0-YDobrBO0N19n5awWUuEY-)

Sempre que você encontrar esse hexagrama no AnyLogic, saiba, meu jovem padawan, que a caixinha de diálogo aceita uma ou mais linhas de comandos.&#x20;

Por exemplo, vamos incrementar a variável **numClientesSistema** toda vez que um cliente passa pelo bloco:

![](https://lh3.googleusercontent.com/oxbOf1BobwoJsBL8hsVe5JYUyNFevP47pJJcQ-HqmroN_zwqGvA6SeIDlm3npTBdU9bPJs1twcx1cLTHcfHyJ3_EXO3nNwOzlGe1bEuncH3Xjr5D7D2H3gn20f-VkgpMmprvQirV)

**Importante**: os comandos colocados nessas caixas de diálogo devem sempre terminar com o “;” (ponto e vírgula).&#x20;

Note também, que as seguintes expressões são equivalentes:

* `numClientesSistema = numClientesSistema + 1;`
* `numClientesSistema++;`
* `numClientesSistema += 1;`

Faça agora o **decremento** da mesma variável no bloco **timeMeasureEnd**:

![](https://lh6.googleusercontent.com/U-TVPnvT9i_yqxXKgHelf_nf_xtW8F_QdgkS29pOEaiAPu72aPexBscZxjvjTVwlZ81LpjwC1lWhaceABEpV0J3umG-yKL2IW1PUwPDswu1WPdt_5rRBdEE1OlQd8q2endieezTg)

Experimente simular o modelo e verifique se as coisas funcionam corretamente.


# Saídas por gráfico: Histogram Data

Como temos uma variável que armazena instantaneamente o número de clientes dentro da agência, uma ideia interessante seria olharmos como ela se comporta (ou se distribui) ao longo do tempo. Para isso precisamos de um **Histograma**.&#x20;

No AnyLogic, construir um gráfico de Histograma exige duas etapas e você vai entender rapidamente o porquê:&#x20;

1. Primeiro, você **coleta** os dados em um bloco **Histogram Data**. Este bloco tem diversas opções de como o dado vai ser agrupado ou coletado e, mais bacana: ele fornece, por meio de funções próprias elencadas no [Help](https://help.anylogic.com/index.jsp?topic=%2Fcom.anylogic.help%2Fhtml%2Fanalysis%2Fhd.html\&resultof=%22%68%69%73%74%6f%67%72%61%6d%22%20%22%64%61%74%61%22%20), diversas estatísticas descritivas e da amostra coletada;
2. Em seguida, você faz o que quiser com os dados, inclusive mostra em um gráfico por meio do bloco **Histogram**.

Comece criando um bloco **Histogram Data** com o nome **clientesHistogram**:

![](https://lh3.googleusercontent.com/cG6H9kENTtkMXEXMQvGjRRKyfbKvuv2oJC4mPUgriB7HpmjtqCwGUI5LQTm29y8Y4qbeuU9TxKQwaUTp34CqGobS7SdUc0Mi2gJehQbQAaXRqy7Py4PPVwE6azGuFJlwb6l0DF0k)

Agora, vamos configurar o bloco, informando que a variável a ser amostrada é a **numClientesSistema**:

![](https://lh3.googleusercontent.com/uiHvnCw12rfLUX3XuZp9Iizwzx0QduMW1X6iSxEnsT9kl8Pv2mnrCaVmHwLrJOmGY1tQRoU43U4AS7Cyg4RkGT0Quj-xs3tT0w9X-dhLaA8fuOkPHSP6IFF1ngAKHdq2GsAM63-l)

{% hint style="success" %}
No bloco **Histogram Data** você ainda pode:

* Calcular os percentis ativando o parâmetro **Calculate percentiles**;
* Alterar a largura dos intervalos do histograma na aba **Values range** (o default é deixar o AnyLogic calcular isso automaticamente);
* Alterar como o AnyLogic coleta os valores da amostra, o que é particularmente interessante caso você queira trabalhar com algum **tempo de warm-up** (veja o apêndice ao fim deste tutorial).
  {% endhint %}


# Saídas por gráfico: Histogram

Depois de criada amostra de dados, vamos adicionar um histograma ao **dashboard** do modelo, arrastando o bloco **Histogram**, como a seguir:

![](https://lh6.googleusercontent.com/mUJhrWTPMboec7DgXNt-fIMN9eAVwFwiLs9W-vbwF58lbk84yuOk2e-uSGlNAHwdmJzt4UyOsalqHB8EwhcCsqI_UDztpkwdXhgsAc0UWY8an80TW40t7oWkmLlgeTDAyLgEXG1R)

Em seguida, configure o histograma:

* Coloque um título emocionante para seus dados: **Clientes no sistema**;
* Com a opção **Ctrl + Espaço** atribua ao parâmetro **Histogram** a amostra de dados armazenada em **clientesHistogram**;
* Para que o gráfico apresente a média do **dataset**, selecione a opção **Show mean**, na parte de cima da janela de propriedades.

![](https://lh6.googleusercontent.com/GDB89f034y5OonRNay5xfTAGCsls2v64KRruPimwxuyc9nmxHd-JlqmWUpQUfO9x74QAtccrltZgcwgJUVMm07N2W63i4Uy0HwXjlvtGOlMd_rlHptb22Nl2jeuFxOtyDH64ivsF)

Agora...

![](/files/-MG-cHNwQJ2ErE7EQ-Ax)

**Simule!**&#x20;

![](https://lh6.googleusercontent.com/dvaxyVpYZFJ0krMk1zVpFToo2DLEouwRyuaFkPXipFo_gfyhk2zVo3IKXg3MUnPjt6Z18-qm-jL1MB35pL1b_jV9npZ5-4qm3P4oo_yoDqkvXGDs7yCC84Cl_XQoFibbRlJTEk7_)


# Saídas por gráfico: Time Plot

Encerrando o modelo, colocaremos um gráfico da distribuição do tempo médio de permanência no sistema. Lembre-se que ao criarmos o par de blocos **timeMeasureStart** e **timeMeasureEnd**, automaticamente foi criado um **Dataset** (ou amostra) do tempo de permanência no sistema. O processo de criação do **Time Plot** (gráfico em que o eixo **x** é o tempo de simulação) já deve parecer bem simples para você:

![](https://lh6.googleusercontent.com/MiBkEglNBoCWNpCU47ovvZGuMFkkED9z7g8VA3RHecdrE3zxalm9FXg_c1DSjG6e0RzTwPGrzukJFkcmZuMppaHxVvT9PTR8OvGnm9VFG8SowpfMbqlN906IrgwZc8zMutJ73jet)

Os valores do tempo no sistema estão armazenados em um **Dataset** dentro do bloco **timeMeasureEnd**. Este **Dataset** é acessado facilmente pelo método:

`timeMeasureEnd.dataset`&#x20;

Contudo, não pretendemos, como no gráfico anterior, mostrar simplesmente a distribuição de valores. Queremos mostrar o comportamento da média amostral ao longo do tempo de simulação. O **Dataset** tem um conjunto de métodos para estimativas de estatísticas, como o `getYmean(),` que fornece tal média. Para acessá-lo, usamos – caprichando no uso do CTRL+Espaço – a expressão:

`timeMeasureEnd.dataset.getYmean()`

O preenchimento do **Time Plot** depende dos seguintes passos:

* Se aparecerem 2 blocos de dados em **Data**, apague um deles clicando no pequeno “x” vermelho na parte de baixo da aba **Data**;
* Crie um título emocionante para a distribuição: **Tempo médio no sistema (min)**;
* No parâmetro **Value** informe qual o valor que deseja no eixo y do gráfico:&#x20;

`timeMeasureEnd.dataset.getYmean().`

![](https://lh5.googleusercontent.com/z0ZCSRMRsfkbElC-AV9BEqtBgu7Bth1oztYo3VORolv7LSGBf08NkKzF-MkqBh18xnVGbWmERomWC08l4XMZODVwCV8-0_McVcUzrU__LUmuVoF95Bprlo7iBuVAEgejkuI5oYIt)

Como a simulação dura **600 minutos**, altere a opção **Time window**, dentro do menu **Scale**:

![](https://lh4.googleusercontent.com/nvgaQ0N4Nc7jklOnN2nqj9uLSkHSoIcPhHSNbhoz-5u_0nlRELjBLHEUd9yrroPCsQfmr380BU-6RtnBcih-VqUlsq3F3PGzunc4oNA90EalFPMhZe7NutCmpv_ojdy_b78NX6ip)

Como último parâmetro do **Time Plot**, precisamos definir quantos dados são apresentados no gráfico, pois o default é limitar o conjunto todo em 100 elementos. Vamos alterar isso na barra **Data update**, aumentado o número de dados para 600 (algo equivalente a uma coleta/min):

![](https://lh5.googleusercontent.com/vZWpztByxJyY_DQWXDMPpUMJCcyL-rHqIXERtU-JNog-ENzpiUs5jnyWT5Tef9w6udgbZA9vHkegmiNOKZ96l-_7PMxLi88vwgzn7DGEL1EU3oUYLejgMtkbtKqJ3ZgylJ8DqluP)

Simule!&#x20;

![](/files/-MG-dVwnmZMAVAEMqC2q)


# Análise dos resultados

Não precisamos de um estudo muito sofisticado para descobrir que esta agência bancária não está bem dimensionada: ao longo da simulação, o sistema ficou ocupado com **169 clientes**, em média! Como a capacidade de atendimento da agência é de até 4 pessoas por vez (1 no caixa eletrônico e 3 nos caixas de atendimento presencial), havia pelo menos 165 clientes em fila.&#x20;

Um olhar atento no bloco **service** vai descobrir que, ao final da simulação, ainda existem 363 clientes (desesperados) esperando por atendimento no caixa!

![](https://lh6.googleusercontent.com/wg8jeJgf07-kE7gfhfRqodEzif7uL6FCJhG4Wfj5p9bNm2v5QmqgV-LpEQueWeXCU0R_O6KGWNhY4Gl87gE_UpclZjz-JkgA6gI4vwq4Dfm7vzv41T-yBsiGqJHMKnAk3_GSHzm_)

Por outro lado, os blocos **queue + delay** mostra que não há fila para uso do caixa eletrônico. Assim, podemos concluir que o subdimensionamento está justamente no atendimento presencial (assumindo que os parâmetros de entrada estão corretos, claro).

Isto ocorre porque o sistema modelado está instável, com taxa de atendimento nos caixas inferior à taxa de chegadas dos clientes (i.e. chegam mais clientes por minuto do que o conjunto de 3 caixas é capaz de atender). Fica como exercício (adoro esta frase) mostrar por que o sistema de filas nos caixas é instável.

Seu objetivo agora, *pequeno gafanhoto*, é descobrir qual o número ideal (ou, ao menos, que você considera ideal) de caixas de atendimento para o banco.

{% hint style="success" %}
**Dicas**:&#x20;

* Quer incrementar seu modelo com um controles em tempo real bem legais? Veja [este vídeo!](https://youtu.be/pd8QMBL-ri4)
* Que tal estudar o que ocorre em cada parte do seu modelo por logs automaticamente criados pelo AnyLogic? Você está a 5 minutos de aprender isto [neste vídeo.](https://www.youtube.com/watch?v=jVkDkXsTIHI\&list=PLUJJN9tmVTj1czFMt9IKi6wge9GnmMTN3\&index=22)
  {% endhint %}


# Enviando o modelo para a nuvem

Para determinar o número de caixas necessários para chegar a um nível de serviço adequado, aproveitando que já temos um modelo de simulação da agência bancária, basta executarmos o modelo para diferentes valores do parâmetro **número de caixas**.

Para estes casos, o AnyLogic possui um **Experimento** específico, chamado **Parameters variation** (ou apenas **Variation**, quando executado na nuvem), que permite simular automaticamente diversos cenários pela variação de um ou mais parâmetros, dentro de intervalos definidos pelo usuário.

Tal experimento poderia ser criado a partir do menu **File > New > Experiment,** mas faremos algo mais bacana: vamos criá-lo no céu! Isto é, [na nuvem do AnyLogic.](https://cloud.anylogic.com/models)

O processo de levar o modelo à nuvem, vai exigir que você:

* Execute o configurador da nuvem no modelo;
* Selecione quais os parâmetros de entrada e quais as saídas do modelo (o AnyLogic Cloud vai construir uma interface para o seu modelo automaticamente!);
* Crie uma conta (gratuita) na nuvem do AnyLogic, se ainda não criou;
* Execute o modelo e veja se está tudo funcionando, antes de mandá-lo para o grupo da família no zap!

O configurador do AnyLogic Cloud é a nuvenzinha na barra do Projeto. Clique nela duas vezes, para que sejam criados os campos onde você definirá os parâmetros de entrada e as estatísticas de saída do seu experimento:

![](https://lh5.googleusercontent.com/pQn1bDsbcnd3fbqhBpnnYzafOKerriRKd-7QbUfkh0iiRRwlEA2G-19yly0DrA_82eEE5Y6phEz74SRZxvdQJmZUEfjjTypaRM7dxVs128WdVv7I8b5GEnABfgiVnnaxLdci11P1)

Selecione, na tela seguinte, quais são os parâmetros de entrada (**Inputs**) e as saídas (**Outputs**) do modelo:

![](https://lh5.googleusercontent.com/ynA3hejhIca-xXIECHNYug8uA3kKVT7gooCPHBQR-TCNRNTgOTB_FK_EN2Irle8FQxwFyaMedCG3k54lciAQkeBxu2tsEicE1jYgIgW6riTmyWcUKpMhidxUzjcKZtOSyuvwNSlu)

Antes de exportar o modelo, atenção a duas mudanças na janela de propriedades: defina o tempo de simulação e o critério de parada da animação antes de exportar o modelo:

![](https://lh6.googleusercontent.com/6LURHM5nBo9kfmVIf6LyhQZCGUN7t3jm0kJvBZX6vY8qEQ3iuALQRE1Md_uMQCumO97LCrtrU2OfAOUNGnLeg2yAORYAfARqbtYf5PIueFnwXDvHNxHH7b2HRvwt_KwZVCXzI8Xk)

Se você chegou até aqui, existe um **link** azul **Export model** na parte superior da janela de propriedades:

![](https://lh6.googleusercontent.com/dIEKWuIPUf_9uuJOA9TGMRuQ87FMApnZh7T7NMT2xZUpXekFrQzq-HGDTosn7kcHIEWEeW3VFQJQRXb1jXvDmb04wXNp7b9pLwIEtvGTKU6QMK0rjhG-_9MyjHE8EZ5DQbETC13i)

A primeira janela deve pedir para você criar uma conta (utilize suas contas nas redes sociais!) ou entrar na sua conta se ela já existe.&#x20;

As telas seguintes são autoexplicativas:

![](https://lh5.googleusercontent.com/uKKHCaj3-9Gm-IGQV1Zs8rC4oklIbnvbzgf0MtMYx1oKk-88gGxWgShq3nlCFzYUNrUzpoRLfBsbQnQDzYC1rYHMoIuyOR7Ey-JC3z01bmJrlnFOVj-HjAbjxZFx5tcG4kk0ZGHh)

Após o término do **Upload**, o AnyLogic deve abrir o seu browser padrão já na tela do modelo, que já está pronto para ser executado!

Olhando o canto superior direito, você deve notar que está numa conta *Guest*, ou seja, ~~chore~~ o AnyLogic não entrou na sua conta. Faça o procedimento de **Login**:

![](https://lh6.googleusercontent.com/ervVAn8AKkU5fkIyS8xrTy7_XgDrlFbFUTA_zO8OLcnXvvOwN6TtQAoizfPHmAzr9ST3D0ylVR1kFPTTSJTbgmATICsexqZ51xo5vtBiDnbvWsojbV2g8DEfD1cuxmXbm06wYe5v)

Inicialmente, temos apenas um **Experimento** na nuvem. Vamos executá-lo, selecionando o **Experiment** do lado esquerdo e clicando no botão de execução **Run** na barra de menu superior:

![](https://lh6.googleusercontent.com/waTFxHhbxJKnpGGzirZnMOdUBrwImhM7oUnjtGYpVnpnZTn019-lcFz9tRYlVOoYB06ixcaI86jKHCQqaY5rkmCABRJsQ1Hn2MF9EZYzp_CaE7fZ_G9m5LvWy4lzU3fz_OZtxaIz)


# Experimento: Parameters Variation

O **AnyLogic Cloud**, mesmo nesta versão pública, permite que você crie novos **Experimentos** (note que a conta gratuita impede que você armazene modelos na nuvem de forma privada, exclusiva para você).&#x20;

Para atendermos nosso objetivo, vamos criar um novo experimento do tipo **Variation**, que permite simular diversos cenários ao mesmo tempo, variando um ou mais parâmetros. Para isto, siga os seguintes passos:

* Crie um novo experimento do tipo **Variation** e dê um nome apropriado, como “Variação do número de caixas”;
* Edite o **Dashboard** deste novo experimento: o parâmetro de entrada **numCaixas** deve ser alterado de **Edit box** para **Varied in range**;
* Salve o **Dashboard** criado.

![](https://lh3.googleusercontent.com/V3DztlFWKHK9iS_GQnIwsAuOzVDPSfmnVTS2c2ZgtLVt42RKJUesAf1gXuCGD60ez8nk-SSWo11_GZ4RoPGdCGQ0hxknSMW5suIjjyGEqN5_EMZ4cWl3BRSsYIFQxEQB0mJxPxPV)

Note que para este experimento, o dashboard do modelo permite a definição dos valores mínimo e máximo para o parâmetro **numCaixas** e os incrementos (**step**) a adotar de uma execução para a outra.&#x20;

Explore o experimento criado, simulando alguns cenários pela variação do parâmetro **numCaixas** (note que as simulações não ocorrem no seu computador, mas na nuvem do AnyLogic):

![](https://lh4.googleusercontent.com/Gdw-K9uydvvlpD-CE62s6sGvlMNVdgVsuXZAHJWZd_-Smt50Iy81DG99HQ4OwyAxTP99enZUZAf8gtvnqzqGp_UPbVCMVnjYI6KAhQyQnMdWgM8Q5TGR1Qn7VR8oAxCq5rZ0I_It)

O gráfico de tempo médio no sistema revela que o Banco somente atinge a estabilidade a partir de 7 caixas abertos. Com 6 ou menos caixas presenciais, a taxa de atendimento do sistema (caixas normais mais o eletrônico) é menor que a taxa de chegadas dos clientes, fazendo com que a fila cresça desenfreadamente ao longo da simulação. Em outras palavras, nos cenários com menos de 7 caixas, quanto mais tarde o cliente chegar à agência, maior será seu tempo em fila e, se a chegada dos clientes não for interrompida (por exemplo, pelo fechamento da agência), a fila de espera tenderá ao infinito.

![](https://lh6.googleusercontent.com/SF1WyU0cQNGx0DqT9D86F--DZzMPdiZThouqN9BamlV2tjV5BUBEqBB50-dX1tRR9G4Ou0q1E_WZREjmg_AZ9qHybbh2rXAEuALIikqZ3SCEIdr2J7NETPLz9gTl93VxqBmexjdv)

Que rufem os tambores: descobrimos que o Banco precisa operar com 7 caixas e, aparentemente, existe algum ganho ainda possível com 8 caixas. A partir daí, com 9 caixas ou mais, parece que o nível de serviço mantém-se constante. \[Desafio: você consegue explicar por que o tempo de permanência dos clientes no banco parece tender ao valor de 3,2 minutos, quando o número de caixas tem ao infinito? Resposta ao final.]

Você notou que o AnyLogic Cloud armazena os cenários simulados? Se você pedir a simulação de um determinado experimento já executado anteriormente, ele não simulará o modelo novamente, mas buscará em sua base de dados o resultado que já está pronto.

![](https://lh6.googleusercontent.com/W5n2QRswkez9hkDze3T63_jzUFUQORxdh9WhXx42HmMCfXVVHnxYRh8kQD-qbUrNkwM3jKLRQHgWen9hzC42PVp15d_Yat73HgxzS54FhTWvW5crq5sI0CQ8RlQwHBIAziKDSt9N)

Você pode compartilhar o link do modelo com ~~seu/sua arqui-inimigo/a~~ os amigos, incorporar o modelo no seu site (ou blog), tornando sua página interativa [como neste tutorial,](https://www.anylogic.com/blog/conveyors-using-the-material-handling-library-part-1/) ou fazer algo bem mais avançado: como uma [interface completa de execução do modelo](https://cloud.anylogic.com/custom-ui-demo/index.html) usando o API da ferramenta.

Para saber mais sobre o **AnyLogic Cloud**, existe uma [página](https://www.anylogic.com/features/cloud/) dedicada no site da AnyLogic.


# Como aprender o AnyLogic a partir daqui

Chegamos ao fim de nossa atividade de lhe introduzir ao AnyLogic. A partir daqui, o que você pode fazer:

* Se você já possui ou pretende adquirir a versão **Profissional**, o caminho natural é fazer um dos [treinamentos mensais oferecidos pela Genoa](https://genoa.eventbrite.com.br/);&#x20;
* O [site da AnyLogic](https://www.anylogic.com/) disponibiliza uma seção **Resources** com diversos livros, vídeos e white papers gratuitos:
  * Para uma visão geral do software, incluindo os três métodos de simulação que ele comporta (Processos, Agentes e Sistemas Dinâmicos), um bom ponto de partida é o livro gratuito: [*AnyLogic in three days*](https://www.anylogic.com/resources/books/free-simulation-book-and-modeling-tutorials/) ou sua versão em Português, [*AnyLogic em três dias*.](https://www.anylogic.com/resources/books/material-de-aprendizado-em-portugues/) Existem, ainda, versões pagas para o [Kindle,](https://www.amazon.com/AnyLogic-Three-Days-Simulation-Modeling-ebook/dp/B07FYP8Y3C) leitor de livros digitais da Amazon;
  * Se o seu foco é a simulação **orientada ao processo**, ou seja, você quer reproduzir aquilo que já fazia em outros softwares de simulação e está confortável com isso; ou se você é um estudante de Pesquisa Operacional e deseja apenas representar modelos como os da **Teoria das Filas**, deixando a Simulação de Agentes para o futuro, então eu sugiro o livro gratuito (e muito bom): [*“The Art of Process-Centric Modeling with AnyLogic”*;](https://www.anylogic.com/resources/books/the-art-of-process-centric-modeling-with-anylogic/)
  * Se você está interessado em aplicações em Logística, Cadeia de Suprimentos, eu sugiro que consulte [esta excelente apostila](https://www.anylogic.com/resources/books/operations-and-supply-chain-simulation-with-anylogic/) do Prof. Dmitry Ivanov, ou que você pule direto para outro software: o [anyLogistx,](https://www.anylogistix.com/) que é um *spin-off* do AnyLogic e já vem com o CPLEX (pacote de otimização da IBM) embarcado;
* Existe uma sensacional [seção de vídeos “How-to” no youTube,](https://www.youtube.com/playlist?list=PLUJJN9tmVTj1czFMt9IKi6wge9GnmMTN3) com legendas em Português e duração de 3 a 6 minutos cada. Sugiro alguns para começar:
  * [Distribuições de probabilidade customizadas:](https://www.youtube.com/watch?v=YniPxHYfbrc\&list=PLUJJN9tmVTj1czFMt9IKi6wge9GnmMTN3\&index=10\&t=0s) você vai aprender algumas técnicas que o AnyLogic possui para leitura de dados e conversão em distribuições de probabilidades
  * [Animação 3D](https://www.youtube.com/watch?v=L5SD_QdUUKE\&list=PLUJJN9tmVTj1czFMt9IKi6wge9GnmMTN3\&index=14\&t=0s): como criar animações 3D do seu modelo;
  * [Geração de logs](https://youtu.be/jVkDkXsTIHI): o AnyLogic possui um gerador de logs automático que é… viciante!
  * [Criação de fluxos de processos concisos no AnyLogic](https://www.youtube.com/watch?v=0Nu1a9Te6ac\&list=PLUJJN9tmVTj1czFMt9IKi6wge9GnmMTN3\&index=8\&t=0s): ajuda usuários de pacotes mais antigos, que tendem a gerar modelos extensos e confusos por conta de vícios de modelagem, a produzir modelos mais racionais;
  * Além da seção **How-to**, a [*playlist* *de webinars*](https://www.youtube.com/playlist?list=PLUJJN9tmVTj1kKggcvpPtVBc7--imAkuW) é muito boa também;

{% embed url="<https://www.youtube.com/watch?v=YniPxHYfbrc&list=PLUJJN9tmVTj1czFMt9IKi6wge9GnmMTN3&index=10&t=0s>" %}

* Dúvidas: atualmente, o melhor lugar na Internet é o [Stack Overflow](https://stackoverflow.com/questions/tagged/anylogic) que possui um grupo bem atuante de perguntas/respostas. Se você possui a licença profissional ou University Researcher, ~~better call Saul!~~ chame o [**Get Support!**](https://www.anylogic.com/resources/support/)
* Com a popularização do AnyLogic, existe uma comunidade crescente de *youtubers* e blogueiros do AnyLogic. Cito alguns:
  * No youTube, um dos bons é o [AnyLogic 101](https://www.youtube.com/playlist?list=PLiGJP0k1miFYSAGsN45QSedkBinTEfItr) do consultor Benjamin Schumann, um cara bem entusiasmado e didático. Há muitos canais de professores, por exemplo [aqui](https://www.youtube.com/watch?v=uuQ-M85aCs0) e [aqui;](https://www.youtube.com/user/NathanielOsgood/playlists)
  * O [site do Prof. Arash Mahdavi](https://arash-mahdavi.com/) é dividido em posts que explicam conceitos específicos do AnyLogic;
  * O Eng. Alvaro Gil mantém [um blog bem legal em espanhol](http://agiltools.com/blogsp/author/alvaro/) (veja os tutoriais!);
  * Aqui na Genoa, a gente gosta muito [do site do Florian Huebler,](https://florianhuebler.com/) que mostra coisas bem avançadas.

Se você chegou até aqui, entusiasmou-se com os recursos do AnyLogic (nuvem, modelagem híbrida, 3D, arquitetura aberta, banco de dados, Machine Learning, geração de aplicativos e um infinito número de abracadabras a se descobrir ainda), mas se o seu professor ou sua empresa ainda utilizam softwares “sem sabor, no sentido de que eles não pensam em ideias originais nem trazem nenhuma cultura em seus produtos”, **chore**.


# Simulação com Replicações

Com exceção do experimento **Simulation**, todos os experimentos do AnyLogic podem ser simulados com replicações. O **Simulation**, que é o tipo selecionado por default do programa, deve ser utilizado quando você quiser executar seu modelo com a animação gráfica ativa.

Nesta seção, usaremos o experimento **Parameters Variation** com replicações, e analisaremos as saídas do modelo por amostragem. Se esta é sua primeira experiência com simulação, talvez não esteja claro o que são e para que servem as replicações, então aí vai uma explicação bem básica: como há aleatoriedade no sistema (por exemplo, o atendimento dos clientes não tem sempre a mesma duração - o AnyLogic sorteia um valor para cada uma das operações, de acordo com a distribuição que nós definimos), não seria adequado tirar conclusões sobre o desempenho da agência bancária após apenas uma execução do modelo. Deve-se, nestes casos, executar o modelo repetidas vezes e analisar o conjunto de resultados obtidos. As replicações são simplesmente as execuções do mesmo cenário, ou seja, do mesmo modelo com os mesmos parâmetros de entrada (e sementes diferentes para a geração de número aleatórios).

Por exemplo, considere que você queira estimar a ocupação média dos caixas de atendimento e que você tenha estimado que 10 replicações é uma quantidade adequada para extrair suas conclusões. Neste caso, você usará os 10 valores de ocupação média (cada replicação gera um resultado) para calcular a média deles, interpretando que este resultado é representativo da operação real. Em outras palavras, você fará uma análise por amostragem e sua amostra tem tamanho n=10.

Antes de pôr a mão na massa, um aviso de algo bacana: o AnyLogic executa experimentos com replicações com **processamento paralelo**, de modo que ele dispara uma replicação por **core** disponível na CPU de seu computador.&#x20;

Velocidade, amigos!

Vamos lá: a criação de novos experimentos é intuitiva, basta utilizar a sequência de comandos do menu suspenso **File > New > Experiment**:

![](https://lh6.googleusercontent.com/cYVlY-oVrMW-ln9gGD5A0yx__q5q26TwZfoPn39a9rmMofcoGfNBU9SAcEwdQNSrfmtCo9OgMfAibYkjsM_-jc7g9I62cD278DjARz8GxM1X1wCwvS07A9Oxszete3gDoVLKVbXp)

O primeiro passo é criar elementos de coleta de dados (**Dataset**, **Statistics**, **Histogram data** etc.), dos quais possam ser extraídas as distribuições dos parâmetros de saída. Embora já tenhamos criado diversas saídas para o modelo, todas elas foram criadas no experimento **Simulation**. No experimento **ParametersVariation: Main**, ainda não há uma mísera saída.&#x20;

Usaremos duas saídas nas análises: o tempo médio no sistema e a utilização média dos caixas. Usualmente, quando simulamos um modelo com replicações, temos um ou mais valor(es) de saída do modelo e queremos estimar as estatísticas descritivas deste(s) valor(es). O AnyLogic fornece várias opções para isto, mas, para este primeiro contato com a ferramenta, sugiro começar pelo bloco **Statistics** da paleta **Analysis**.&#x20;

Depois de alguma prática, conjunto de passos é simples:

* Determinar a estatística de interesse (no caso, a utilização dos caixas);
* Criar um bloco **Statistics** com a opção de atualização de valores **Data update** na opção **Do not update data automatically**;
* Ao final de cada replicação, adicionar ao bloco **Statistics** o valor da estatística de interesse e resultante da replicação, por meio do campo **After simulation run** na janela **Properties** do Experimento.

Vamos começar criando um bloco **Statistics** com o nome **utilizacaoCaixas**:

![](https://lh3.googleusercontent.com/rw5o9ObGjfQQOaIHz1pRFqfLtCu8SLt7FhUSKU197Hlvrv1TdVX1AwjQZ7zG76rCXxOobtzKeMLx03mVK2MeHT3bvMWT0ekzAq_r3xH0rdOSoBlnUTIMYFqbrozWA5vqP4h5lP7y)

Deixe a opção de atualização de dados na opção **Do not update data automatically**:

![](https://lh3.googleusercontent.com/frw2WY94gU_nQzZeX4ecIyhPimYISeA25LeNgmYNLFd9atCWzvgxbF08AwREB2NZBjlhLTCQhA899XIuCjvw8WDGzk1ezwuENCakJKpLqoqBpnlNyuibXNWHxcrJ0A85Iw4W7ecE)

Nosso objetivo é adicionar, ao final de cada replicação executada, o resultados da respectiva replicação no bloco **utilizacaoCaixas**. Volte à aba **Projects**, selecione o experimento **ParametesVariation: Main** e, na janela **Properties**, localize a linha **After simulation run**, no menu **Java actions**:&#x20;

![](https://lh6.googleusercontent.com/ccZQkjl-vZ_CUdlKump_GNEVH0_KTHGkiIJEgtwhq8ZCbvCwMo-z-xCuSnY_9fycya2LGcNBY1dNgbhhSunsBbAs1AN73ic8VNNg82ptpdsVgq-vVlUMaU1nnfYAIrYpiuQJ23pL)

Esta linha de comando (que no momento está vazia) é sempre executada quando o AnyLogic termina a simulação de uma replicação.&#x20;

O bloco **Statistics** possui a função **add()** exatamente para isso, de modo que a expressão para se adicionar um valor para o bloco **utilizacaoCaixas** seria algo como:

`utilizacaoCaixas.add(`*`...alguma estatística…`*`)`&#x20;

ou (acostume-se com o comando **Crtl+Espaço**):

![](https://lh3.googleusercontent.com/T58WjjMbx9RktdOY0eFrIEDvyOkP13F2QhTIWvOMTQr7dnlGOINr6_cvX6sA0BIcAVWDoyxeCpKQz9u8X_k6h_IhSbWeSH48gK2kkCEw3kz9fycWJuHok4KedRG24N3gQx9zvybL)

O nosso modelo já calcula a ocupação média dos caixas, dentro do bloco **Resource Pool** (aquele que está lá no nosso **Main** e apelidamos de **caixasDeAtendimento**), por uma função chamada `utilization().` Sendo assim, para acessá-la basta digitar: &#x20;

`caixasDeAtendimento.utilization()`

Mas tem mais um detalhezinho: se você pousar o mouse na lampadinha amarela na linha **After simulation run**, vai receber a dica da palavra **root**.

![](https://lh5.googleusercontent.com/Uq54EpNoBS0marNJpd60giXVSa_JrhxlSZs89rFxEiQuonRiRPDjxl8Vh3y_0Y3MA3ga09Yc1u2hWDon4-0NkFjL6EFA-YU1LxcSM0wDSH_gpNcx69kjxkIqPHnx_SbAfyULDQT6)

Com o comando **root**, você acessa cada replicação assim que ela terminar. Veja na figura como ficou o comando completo (a cada ponto digitado, **Crtl+espaço** e **não se esqueça do ponto e vírgula ao final**):

![](https://lh3.googleusercontent.com/kl_1Mwxvbq7UcFb-5TcbNQoyXn4d1bz6NTJMDxcYaw2J11ZwbIIHyaFqEPaXbDWxjUVgDqfzx3azwGFbNiYre7Wwzk5LE4tdrfZSMpx86LNklMJ0gPsqNi12ZsW7a1Gg-UibuP9v)

Um breve resumo do que fizemos até aqui:

1. Criamos um bloco **Statistics** **utilizacaoCaixas** dentro do **Parameters Variation**.
2. Nas propriedades do experimento **Parameters Variation**, colocamos no campo **After simulation run** da aba **Java actions**, o comando:&#x20;

**`utilizacaoCaixas.add(root.caixasDeAtendimento.utilization())`**

A sua atenção agora deve ser direcionada para a janela de propriedades do experimento, na barra **Replications**:

![](https://lh6.googleusercontent.com/bZX6Ly5K5Q98Ws9YJMiM4-PcCW_yWxCF2i_8pweu5IrTO-4SosgXc9CvIbarMs7RddeotSNAAOX2Dzdi22bFDHqe1nnFuYSu4EeTdhn0cmt7Y51v02Uw2QCf3x4qHMrW1Gahznzt)

A opção **Use replications** abre o resto de opções da janela:

* **Fixed number of replications** para executar um número fixo de replicações;
* **Varying number of…** para executar um número de replicações tal que garanta que o **intervalo de confiança** para determinado valor (parâmetro **of expression**) seja uma porcentagem (parâmetro **Error percent**) do seu valor médio.

Outra coisa importante: **o&#x20;*****default*****&#x20;do AnyLogic é manter a semente do gerador de números aleatórios fixa**, garantindo que os resultados das simulações com mesmo valor de semente sejam sempre iguais (mesmo que executados em computadores diferentes, por exemplo). Isto se aplica mesmo entre replicações, o que nos obriga a informar ao AnyLogic que queremos uma semente diferente a cada simulação. Isto é feito na aba **Randomness**, trocando a opção de semente para **Random seed**:

![](https://lh5.googleusercontent.com/ZqJz0ZqfLtOtv3B4gYR_b1aKd3kX0qbjdMc0Xg0P9EcLOM-RMTK-bsNySUPOA7Klp0Xn9C2SywwS7tAeAFAsexcgPKmhihnQCa-G0Vj5bgiuS-VWj81KnyFGxuof7N4yYAPe7x8U)

Agora é só simular e você terá o resultado da simulação para o número de replicações desejado.&#x20;

Observações:

* O bloco **Statistics** possui diversas funções para extrair a média, o menor valor, a variância etc. [Veja as opções no Help!](https://help.anylogic.com/topic/com.anylogic.help/html/analysis/statistics.html?resultof=%22%53%74%61%74%69%73%74%69%63%73%22%20%22%73%74%61%74%69%73%74%22%20)
* A sequência de passos anterior pode ser utilizada também para o bloco **Dataset**. Quando devo utilizar o **Dataset**? Quando você deseja armazenar a amostra, os resultados de cada replicação (em contraponto, o bloco **Statistics** não mantém a amostra utilizada nos cálculos);
* O Experimento **Parameters Variation**, permite simular com variação de parâmetros. Por exemplo, poderíamos simular nossa agência bancária para valores do número de caixas abertos iguais a 1, 2, 3, 4… Neste caso, deve-se tomar cuidado, pois apenas um bloco **Statistics** não seria suficiente. Precisaríamos de um bloco de estatísticas para cada parâmetro de entrada diferente. Foge ao espírito deste tutorial, mas uma boa alternativa neste caso, seria utilizar [**Collections**](https://help.anylogic.com/topic/com.anylogic.help/html/data/collection-variables.html?resultof=%22%63%6f%6c%6c%65%63%74%69%6f%6e%22%20%22%63%6f%6c%6c%65%63%74%22%20).


# Tempo de warm-up

Seguindo a máxima eterna de que no AnyLogic existem *n-k-pi* maneiras de fazer a mesma coisa (~~chore~~). O tempo de aquecimento ou de *warm-up* tem uma primeira bifurcação na largada, dividindo os sábios que possuem uma licença do software, dos sábios que queriam muito ter (mas por enquanto estão usando uma versão PLE):

1. **“Eu tenho a licença!” \[Snapshoot]** O AnyLogic tem recursos diferenciados para o tratamento do tempo de **warm-up** da simulação. Um deles **somente está disponível** nas versões **profissional** ou **researcher**: a possibilidade de salvar um [snapshot](https://help.anylogic.com/topic/com.anylogic.help/html/running/snapshots.html?resultof=%22%73%6e%61%70%73%68%6f%74%22%20) do modelo. Um **snapshot** salva o estado atual do modelo durante a simulação, gerando um **arquivo de estados**. Tal solução elimina a necessidade do tempo de **warm-up**, bem como deixa a simulação **bem mais rápida**, pois você não precisa re-simular o estado inicial (afinal, ele já está simulado e salvo). Te confundi? Veja o [vídeo explicativo](https://youtu.be/m1tDjwOqTBg) no YouTube.&#x20;
2. **\[Parâmetro de warm-up]** Neste tutorial, não utilizamos tempos de *warm-up* nas simulações, visando manter alguma simplicidade do material. Não por acaso, o exemplo modelado (uma Agência Bancária) é um **sistema terminal** que, justamente por ser terminal, **não necessita de tempo de** ***warm-up***! Porém, para quem utiliza a versão PLE e precisa do tempo de *warm-up* no seu modelo, o AnyLogic tem um arsenal infindável de opções. Alguns caminhos simples para quem está começando são:
   1. Crie um parâmetro no agente **Main** para armazenar o tempo de *warm-up*, por exemplo **wupTime**;
   2. Em cada **Dataset** criado, selecione a opção **Update data automatically**  e coloque como **First update time** o parâmetro criado, como no exemplo:

![](https://lh4.googleusercontent.com/4MPg04iTgHIGaDOdr0yZZJ3tbzCWe0A9szW4dqzaX5wjcejxH8A2gHtAyCmK_BGsscDk6LJhVLYM7iaxQLC9p5u5kc9BZgCz_M5g921V6zL3fX4lvNKP-Cj64Q6gnAJSh2V2oHxE)

1. O bloco **Statistics** (e todos os blocos da paleta **Analysis**) possui(em) a opção **Update data automatically** que permite definir o momento de início da coleta de dados. (Lembre-se que utilizar esses blocos facilita, inclusive, o processo de simulação na nuvem):

![](https://lh6.googleusercontent.com/6V2uT08Zm78P8Ko4rKaNyrDCFIj4fqNtJfTDjNtdk-jcNhtXQWHGi0NRSybo1-kqgCjf8h8BCCojye3HRiaGhNvDLAo6YjnyV670RuAXHQTozE3ZNpENfg0XToMT8tLpQ46uEZgm)


# Comunicação com planilhas Excel

Para conexão com o **Excel** (entrada ou saída de dados), o AnyLogic fornece diversas alternativas. Basicamente, há duas opções indicadas para iniciantes:

* Importar os dados da planilha Excel para o banco de dados do AnyLogic;
* ou conectar diretamente a planilha Excel como um objeto dentro do AnyLogic.

## **Importando os dados do Excel para o banco de dados do AnyLogic**

&#x20;Neste caso, os dados da sua planilha do Excel devem estar com uma “cara tabular”, pois, no AnyLogic, cada pasta do Excel será importada para uma tabela do Banco de Dados e \[importante!] a **primeira linha** da pasta será utilizada como título das colunas da tabela. Por exemplo, considere a seguinte planilha Excel:

![](https://lh5.googleusercontent.com/ou2jhBLf_s-JZ5-CNgUHzfmE97n4RDVBrdcm6IeNbo8b1Y-I_tTBZJNGFKXnJjvAaSH_wPazkS2_fDTSYnsEMNmnPB6nBRYybrhrxG0Fs3jLtTa3qtETfED-BbsPHVE-TADmKchZ)

(Note que a primeira linha está preenchida com os cabeçalhos da tabela. Se não fosse assim, haveria erro na leitura do arquivo.)&#x20;

Para importar a planilha para o banco de dados, siga os passos:

* Clique com o 2° botão do mouse em cima do ícone **Database**, na aba de projetos e selecione a opção: **Import database tables**;
* Localize o seu arquivo Excel (ou tabela de banco de dados);
* Selecione, se for o caso, as pastas que queira importar e aperte o botão **OK**.

![](https://lh6.googleusercontent.com/O97etWhrnEzDheiKNGCP_ENpdbMnNY2cvMcwBQ19lmiihL0tnHW_WoadY3MRElCz2lYVaFbsq8NOnDeYM81H-EUzz-HaUNO1ALwVe4Smh8SGLUKnuxUrvU5Z2lV6bioMgsApEJ3W)

No exemplo, a planilha foi importada como uma tabela e, com dois cliques no seu ícone, você pode visualizar os dados armazenados:

![](https://lh3.googleusercontent.com/8bLBYZr5n2qlza00cMTiOg9qbNcLpY4f6BDpLGyiImqJmoMCtCuLyodDVxESUpCUCLzYkkz84AoXB_ALJpqFhHeVPXq669ToOo5u2zPaPpL2xngTIRDEyudsBeDFpYSN9pavz3ru)

O uso dos dados da tabela pode ser feito diretamente pelo comando **Insert Database Query**.&#x20;

Por exemplo, vamos utilizar a “Taxa de chegadas de clientes”, armazenada no banco de dados, como valor de entrada para o parâmetro **Arrival rate** do bloco **chegadas**. Neste caso, você precisa:

* Selecionar o campo onde o valor será preenchido (no caso **Arrival rate**, do bloco chegadas);
* Clicar no ícone do  **Insert Database Query** (note que ele só fica ativo quando você entra no campo **Arrival rate**);
* Selecionar a tabela com os dados em **Table**;
* Criar uma condição de pesquisa (note como o AnyLogic auxilia o processo, abrindo automaticamente as opções).

![](https://lh5.googleusercontent.com/TF4M9c0HzofaUeceEdunzK7-UQq5P3DNT-rVWb4bw6-9hP7lM5NWyuPOhDsv9oCAmFbrs3Z_EPJ0eyi_lrhB--Hv0ODRMK9JnmRXoDeDwMfI4fOuMjPlXQ-xjrBN2Uy4MVUoU0c0)

Você precisa importar uma programação de chegadas que muda sua taxa em intervalos ao longo do dia? O AnyLogic [tem uma maneira bem bacana de fazer isso!](https://help.anylogic.com/topic/com.anylogic.help/html/data/schedule.html?resultof=%22%73%63%68%65%64%75%6c%65%22%20%22%73%63%68%65%64%75%6c%22%20)

## **Conectar diretamente a planilha do Excel como um objeto dentro do modelo**

Neste caso, você deve trazer o Excel para dentro do modelo, por meio da paleta **Connectivity**:

* Arraste o bloco **Excel File** para o modelo;
* Selecione a planilha desejada na janela **Properties**.

![](https://lh5.googleusercontent.com/gkf8SKDVpCKMFFk8MBrL_jCL0zQR2PVYnoBGpaNjjX_488mSV2BF04AAK0uMqHmQIJpC0mpfglYox6tsC4-w47y7V9mywIuIX_gfQUHxiq3GGJSraGky286564w5yyYGoE3OXzxq)

Para importar/exportar valores entre a planilha e o modelo, são muitas funções, mas as principais são:

* **`getCellNumericValue(String sheetName, int rowIndex, int columnIndex):`**`sheetName` é o nome da planilha (por exemplo: “Inputs”), enquanto `rowIndex` e `columnIndex` são os índices linha/coluna da célula **contados a partir de um**;
* **`getCellDateValue`**`(String sheetName, int rowIndex, int columnIndex):` idem ao anterior, mas para uma data;
* **`setCellValue`**`(value, String sheetName, int rowIndex, int columnIndex):` exporta um valor para o Excel. Por exemplo: **`excelFile.setCellValue(2.0, "Outputs", 10, 2);`**  exporta o valor 2.0 para a célula da linha 10 e da coluna 2 da pasta “Outputs”;
* **`writeDataSet`**`(DataSet dataset, String sheetName, int rowIndex, int columnIndex)`: idem ao anterior, mas para um **Dataset** completo.

Todos os comandos possíveis com planilhas estão bem documentados no [Help do AnyLogic](https://help.anylogic.com/topic/com.anylogic.help/html/connectivity/excel-file.html?resultof=%22%65%78%63%65%6c%22%20%22%66%69%6c%65%22%20) e existe um modelo exemplo absolutamente completo no AnyLogic (procure por “**Reading and Writing Excel Files**” no menu suspenso **Help**, opção **Example Models**) ou você pode [executar sua versão na nuvem aqui](https://cloud.anylogic.com/model/99d9f196-17e7-47c3-9b28-63a6f23b0dad?mode=SETTINGS).


# Leitura/Gravação em arquivos txt

Na paleta **Connectivity**, também é possível criar conexões diretas com arquivos texto (“.txt”):

* Arraste o elemento **Text File** para o modelo;
* Configure seus parâmetros de nome/local (pode ser um arquivo da Internet!), se vai ser de leitura e/ou gravação e, caso seja um arquivo de **leitura**, indique o separador (linha, Tab, ponto e vírgula, vírgula ou espaço). Se o arquivo não existir, o AnyLogic vai criá-lo;
* No local que deseja ler/gravar algo no arquivo, utilize o nome do arquivo, seguido do ponto final e a função desejada (por exemplo: **`println, readln, printf, readString()`** etc.).

Por exemplo, vamos gravar em um arquivo os resultados das replicações para a ocupação dos caixas de atendimento. Vamos criar um bloco **Text file** dentro do Experimento **Parameters Variation**:

![](https://lh6.googleusercontent.com/KATrD1x-JE3UxflrDABFqOIMeh6PojuE9PyJ_ge65RcpiC39bqLuMR6T2TvtpKWWOAHN82Z7IKv8oxHnPAuBhGyL9BZJBJKwVaev0GCpVOMeLZCNJS1wEPceRX47kRxIWQ_S568_)

Para isso, precisamos ir ao Experimento **Parameters Variation** e acrescentar à opção **After simulation run** o comando de gravação no arquivo.

A utilização é semelhante à do Excel. Escreva o nome do elemento, digite o ponto final plaft! Use o **CTRL+Espaço**;

![](https://lh6.googleusercontent.com/6t6CrBfLphOz-vCH8TNapMBMRMynMEdE9L9yAZbq9CxpRZE53soAE9WlfzYkZG7twnBH0LA3DBynJm03S0e_4tvpW_NO-HBQy-I5nH76B9KAUCptUvgnn-T-y7pkhxX1UVOdeRgO)

Se você simular o experimento **Parameters Variation** até o final, o modelo deve criar um arquivo **saida.txt**, com os resultados da ocupação dos caixas de atendimento para cada replicação simulada.


# Entidades, agentes, atributos & variáveis

Embora o termo “atributo” não tenha aparecido neste tutorial, ele é usual em livros de simulação de eventos discretos. Na simulação baseada em agentes, em que se baseia o AnyLogic, o atributo é representado como uma variável que pertence ao agente.&#x20;

Imagine, por exemplo, que queiramos criar um atributo que representa a hora de entrada do cliente que entra na agência. Neste caso, precisamos, inicialmente, criar um **Agente** que represente o cliente. No AnyLogic, criar um agente é tarefa para a paleta **Agent**. Clique nela e arraste o ícone vermelho para dentro da área do modelo:

![](https://lh3.googleusercontent.com/n23p6I-goUua8mT_zu4LZXeBJmtHKGr-9y5OxKK21NwDFAuyu0ythR6Xt2mML7Cm1X2mVYDHuBShEnq7je-VC6umPxeuos4qAKPwURgb3ePGnP1j7tBrlCFGWAIZ8HNq54rSsNUX)

O AnyLogic vai abrir um *wizard* para criação de agentes, populações ou tipos de agentes. Com a prática, você descobrirá diversas maneiras de criar agentes, mas o *wizard* sempre será a mais didática.

Queremos criar um tipo de agente, chamado **Cliente**, não estamos preocupados com uma população (com tamanho limitado, por exemplo), então nossa escolha deve recair na 3ª opção, **Agent type only**:

* Clique em **Agent type only**;
* No **Agent type name** coloque o nome Cliente com a primeira letra em maiúscula, pois é uma convenção adotada pelos usuários;
* Clique no botão **Next >**;
* Como não queremos utilizar animação, selecione **None** e, a seguir, o botão **Finish**.

![](https://lh6.googleusercontent.com/Q5owRSuOmWcZCjPU35lWkBj0dJjeIHE7fFTrae9gk0ygRK0AIW2SJ83toPquxXAmrA78-GgCNDA-J5NBXSfF2emjM9WvfbJgl3THCsPDRyiiTc-EAYL8i8bkUPhSqUrBuMiJGA1L)

O AnyLogic criou um novo tipo de agente chamado **Cliente**. Note que ele já abriu a tela do agente para que você possa modelá-lo como quiser. O agente também aparece na aba **Projects**:

![](https://lh6.googleusercontent.com/SlQ_9rsymPBK0LmaWf4bPLauPHidh2KKKZN1viNSXf12tcMH4Uue4-TqpngZ--pk_l3U_x3oKYUv94zADqlqLDgxDQ0VPmw9x9TRqamPfeHETx4WePh5mXa2RJjnwuu7ZjdXUGrg)

Queremos criar um atributo **tempoEntrada**, que vai marcar a hora exata em que o cliente entrou no banco. Basta criar uma variável com o nome **tempoEntrada**:

![](https://lh5.googleusercontent.com/DHlI8BXBUyibULjcOBH5Hrv9lDYJwaGRs-5PmRn5SGPMLG7avPVlNA6z8BA1i3PvQnI1oW-4Dw9jjuKnHWaQqwS7JuGt7__-X1hgNZTlpxvrGV87kc96AKJCgGDwk33V0QX7GKN8)

Agora, volte ao **Main** e informe ao bloco chegadas (que é um bloco do tipo **Source**) que o agente a ser criado é do tipo **Cliente**, usando os seguintes passos:

* Selecione o elemento **chegadas**;
* Em **Properties** abra a barra (o menu) **Agent**;
* Em **New agent** substitua para a opção **Cliente**.

![](https://lh6.googleusercontent.com/CrZb36OTIMFZOGmgNH9gdSf4ASEOhFpDY3x7fO0tNF-eIbTJm_Pj3IdrXCD_thtVMrcgXBNsaQsDxrB1WsaHv5UAfMrjdZcWQdkHoJDbE3qTx4qK1W4pXjmY5U7y-jmfb_Mik8Oi)

Para atribuir o valor da hora atual de simulação a cada cliente que entra na agência, o AnyLogic dispõe da função **time()**. Assim, vamos atribuir o tempo de entrada logo no bloco chegadas:

* Procure a barra **Actions** na janela **Properties** do elemento chegadas;
* Em **On exit**, digite:&#x20;

`agent.tempoEntrada = time()`

![](https://lh6.googleusercontent.com/YiN8pnBF1QJ8y7YlmDqZOPQ2i-jRUhhZ9Stdgzv0zaaUZTwZCuU3j_TqoxtyJ-QWjBB3Ep-7zyRC99GYvRVeVcSRG3KOfe2gKobXCXjgQR-z8wJqu0eYxRhJXXXRwY5uF01semQ7)

{% hint style="info" %}
**Observações**:

* **agent** é o nome genérico do agente que está passando no bloco. Como ele é do tipo **Cliente**, o AnyLogic sabe que ele possui a variável (atributo) **tempoEntrada**;
* Todo bloco do AnyLogic possui as opções **Actions** onde você pode acrescentar comandos que são executados no momento que o agente entra no bloco, sai, é destruído etc;
* Assim, se você quiser, por exemplo, calcular o tempo que o cliente ficou na fila do caixa eletrônico, basta acrescentar ao campo **On exit** do bloco **queue**, a linha de comando:&#x20;
  {% endhint %}

`agent.tempoEntrada = time() - agent.tempoEntrada;`

ou

`agent.tempoEntrada -= time();`


# Animação

Construir a animação de um modelo baseado na biblioteca de processos, como este da agência bancária, é uma tarefa fácil no AnyLogic. Na maioria dos seus modelos, você provavelmente preferirá construir a animação simultaneamente ao encaixe dos blocos de processo, por duas razões:

* Qualquer modelo com animação fica mais fácil de entender, achar erros e, principalmente, vender a ideia para parceiros;
* É fácil de fazer animação no AnyLogic e o resultado é muito bacana.

Você já sabe, mas não custa lembrar: no AnyLogic existem diversas maneiras de se  construir a animação. Usaremos a maneira mais adequada para quem está começando. Quer evoluir suas animações? Então... já sabe, né? Estude os exemplos!

(Quase) todo bloco do AnyLogic possui um parâmetro **Location** ou algo similar. Por exemplo, encontre a região **Location of arrival** (localização de chegada) do bloco **Source**:

![](https://lh5.googleusercontent.com/glMQq5WUgwrykhusgeaqbhH9Rj_Gt1kU-YoZYvZ25qzlvuq2D-Q1aWSD3Hfcd0giA0Y6A9GziAwi84mxAEEdpDyBfyab1ZAikLjuKTh2twwdCiaXygUsoJgPhkbv4UPSi6KE0JbL)

No parâmetro **Location of arrival**, existem as seguintes opções:

* **Not specified**;
* **Network/Gis node**: utilizaremos esta opção. Com ela, marcamos pontos na tela para o deslocamento dos clientes. Caso você pretenda trabalhar com georreferenciamento tem um [vídeo explicativo aqui](https://youtu.be/UKCd6BFwdlg), mostrando que o AnyLogic pode baixar automaticamente da internet mapas, shapes, rotas etc.;
* **Attractor**: serve para controlar o local que os agentes ficam quando você utiliza uma área como ponto de espera, por exemplo. [Veja uma explicação mais detalhada no help](https://help.anylogic.com/index.jsp?topic=%2Fcom.anylogic.help%2Fhtml%2Fmarkup%2Fattractor.html).
* **(x, y, z)**: uma maneira de deslocamento bem sofisticada, com posicionamento por pixels, o que obriga o usuário estar atento à escala utilizada (atenção quando usar este método!);
* **(latitude, longitude)**: autoexplicativo, este tipo de localização é útil em modelos georreferenciados;
* **Geographic place**: permite que você especifique o local exatamente como o faria no aplicativo de mapas do seu celular (i.e: “São Paulo” ou “São Paulo Av. Paulista” ou etc.) - também útil em modelos georreferenciados.

Com a prática, você vai notar que nem todas as opções de localização estão disponíveis em todo bloco, pois o AnyLogic já pré-define o que pode ou não ser utilizado em cada bloco.

Para começar, vamos marcar alguns pontos na tela, chamados de **Nodes** no AnyLogic, que representarão os locais da nossa agência. Precisamos dos seguintes nós:

* Um nó para a porta de entrada/saída;
* Um nó para o caixa eletrônico.

Toda locação de nós, caminhos etc. (seja georreferenciada ou não) é feita pela Paleta **Space Markup**:&#x20;

![](https://lh4.googleusercontent.com/43nCIL0Y-qwNA-hJJx-uDQiHe6wXA7ztE7U1aZvYr7M16O1o5z9ATM89i5D81RVa9_TZE55mjJVKImGz9NAcABEKi6OLSz_jGGbWQa_4csUqSHeyEE47mccTsGzcyyGCEkoKLeIp)

Na parte de cima estão os comandos de marcação de espaço:

* **Path** representa um caminho que os agentes podem circular ou mesmo uma fila (única) de espera;
* **Rectangular Node** representa uma região retangular onde os agentes podem permanecer, como uma área de espera ou mesmo de atendimento. Este tipo de demarcação também interessa aos blocos de **Resource Pool**, para recursos que podem se deslocar, como uma empilhadeira, por exemplo;
* **Polygonal Node** idem ao anterior, para uma área poligonal;
* **Attractor** representa uma marcação colocada dentro do **Node** (**Rectangular** ou **Polygonal**) que atrai o agente quando ele está em espera ou atendimento na região, deixando os agentes organizados na área segundo algum padrão desejado como, por exemplo, cadeiras em uma área de espera, veículos em um estacionamento, operadores junto às suas estações de trabalho etc.;
* **Pallet Rack** um rack pronto para colocação de pallets como num depósito.

Vamos começar construindo a animação da região do caixa eletrônico. Basicamente, precisamos apenas de dois elementos:

* Um **Point Node**, que representará o local de atendimento do caixa;
* Um **Path** que representará o local de espera da fila única do caixa.

A colocação elemento **Node** do caixa é direta:

![](https://lh5.googleusercontent.com/qhNEmjbIgwfQwQia2ju9JzoLasLCBS6didPx49c4U7F-F02usxv8MagG0nIEnv6z029u37MJo4O3zw-xGUrYUvMTaJKQcka3xgTqI7za4-KEEFRSydpnwn3U3TufEVkp8brUW6eV)

Para o **Path** da fila, temos uma novidade: você deve ter notado esses ícones amarelinhos, em formato de lápis, ao lado dos elementos da paleta de marcação de espaço. Este ícone indica que, nestes elementos, se você der **dois cliques**, vai ativar o modo de desenho. Por exemplo, no caso da nossa fila de caixa:

* Dê dois cliques no elemento **Path** para ativar o modo de desenho;
* Clique em algum lugar da tela marcando o início da fila;
* Dois cliques onde queremos o final da fila.

![](https://lh4.googleusercontent.com/xlQ9pDVAZ-7pFRlAZeH38GyGqX1jyGPWcX8GWrMLgyP0aDT_Uy6zA5sQGxpME7mQNdvjAe_DlUvP_PEQ1rnnLgxX8jkaSYX-NmzvWyrQSUxFMix9ge2Th1lSjXcFR0bOOXjtwDzX)

{% hint style="info" %}
**Dicas:**

* Se você quiser modificar o formato da fila (em forma de serpentina, por exemplo), basta dar um duplo clique em qualquer lugar do **Path** que ele divide em mais segmentos;
* Clicando com o **segundo botão do mouse** por cima do **Path**, aparecem novos comandos de manipulação, inclusive a conversão do Path em arco. Se você tiver que desenhar segmentos curvos no AnyLogic, o melhor professor à disposição [é este vídeo](https://youtu.be/p2OOblCTXnY).
  {% endhint %}

O segundo passo é conectar os elementos de marcação de espaço ao blocos de processos, como ilustrado a seguir:

![](https://lh5.googleusercontent.com/Co58GC3ZND7vCwkm-wCRl8T9gbnHNPC2P3_J0sGaPZsv7c-CVwhZZaZYVkabQB2V8OpjVxHYT7mgaDaQ9rnc7vBngVyF4wKzg5ruIeiVJqRrDJNg5DfDoNx0bv7594u1XfWrVeVx)

**Alternativa:** existe um plano B para a marcação de espaço. Ao lado do menu de opções do **Agent location** existe um botão verde que permite selecionar diretamente o marcador de espaço na tela:

![](https://lh3.googleusercontent.com/pFg-vohjgI7ad2joznBMIandO0byk4LYGh2eX7H6AICQ5IY1jL8FJgASXBNx-vYGsYJwK61eUxKL1KhZX2ECvHuMPV4GARNF-gnZ4lDT6wjiFw58X0g3KNXUHGy0pgFr6y33VKl1)

Agora, vamos representar a imagem do cliente. Se você criou o agente **Cliente** como explicado na seção “**Entidades, agentes, atributos & variáveis**”, navegue diretamente para o respectivo objeto:

![](https://lh6.googleusercontent.com/-Ux9ElV86oi-aGfgQL0ZkrIFXI36yCAJt85RfjkOWJH8kaUTsiJ67PDiUiraJBOnXZJBkFnqoFeep2LxDJ5x12epEShEiI-Wcxs7TQ6-KIazKlp_Stbl8XT_-vqf026CAcfIBh0G)

O que você desenhar nesta aba servirá para representar o agente, ou seja, aparecerá na tela da simulação toda vez que um agente deste tipo for criado (i.e. vai substituir as pastilhas coloridas). Por exemplo, podemos colocar a representação de uma pessoa em 3D, existente na paleta **3D Objects**:

* Navegue para a paleta **3D Objects**;
* Selecione o elemento em 3D desejado e **arraste para a posição 0,0** do agente ou onde os eixos se cruzam na tela;
* Aceite a opção de ajuste de escala automática.

![](https://lh6.googleusercontent.com/WhUNGGsrVSSRpSLW5W3xPSF6z2VM0pqjJEn4jlHU127OIlp46WFF91E1Ar0rCRm8vxfu225Hzm572YMKBZjjIjbsq5mR8x8RjZLWKhPL6gTv6V67fbSKFkuQFanrRQ4DznfpYrU6)

Se você clicar no **3D Object**, poderá averiguar suas propriedades (note que, neste ponto do Tutorial, possivelmente você já compreende melhor um bloquinho apenas por uma leitura da sua aba **Properties!**):

![](https://lh6.googleusercontent.com/P0gaQE546nxhNEyMKYocmOhLaqVZ6JEhS88eTWZAPLKK5pjSnoZnf2LkqEhp8Bs9A5CahV7a41YptD7UBPB0nCIpXr2YQ5jv-1GRNkkWqHZ0lrgKZPVFNc5viQKg7u5E5SZf-fdi)

Eu destaquei, em amarelo, um parâmetro interessante: ele determina quando o objeto vai aparecer em tela: 2D/3D ou ambos. Isto pode ser interessante quando você tem imagens que quer em 2D e não em 3D (por exemplo, esse ser *humaninho* não é lá muito estético em 2D. Uma [imagem do R2D2,](https://www.flaticon.com/free-icon/r2d2_86482?term=r2d2\&page=1\&position=16) talvez, ficaria melhor:nerd:) ).

Se você simular o modelo, vai notar a fila se formar junto ao caixa e só isso.&#x20;

![](https://lh5.googleusercontent.com/xk15duYl3Wh-Qy2T30emYJsXaulvZTgo2vkShQk8Hu9-z4NIRQLHDe4opLEpHtJEq5fuF7UtnzG2Z9nTsjvWRQWo3tiG92YgfeVOgJC3YulCsk2FpHQJk2DSWpgiYZI9hGy_HZsM)

Vamos melhorar as coisas:

* Colocar um **3D Object** representando caixa de eletrônico físico;
* Criar uma janela em 3D para visualizar a agência.

O caixa eletrônico fica na paleta **3D Objects**, no menu de **Supermarket** (a imagem é pequena, mas eu já sei e vou te contar que você deve girá-lo 90 graus, caso contrário o cliente vai olhar para o lado errado do caixa):

![](https://lh6.googleusercontent.com/g9P78UylO0YFUqROteU3fQC3bIOeE1NHuzQd-TzLWfl9_hTds7uuHrXvNStg_9ENlPri_xwbDeKz15T3mb9tZS5oTdqcbOHWa5XRg4gwZNg9nvxcPX0hIJRT2p4jJRNQed9jElF7)

A janela de visualização 3D, **3D Window**, é arrastada a partir da paleta **Presentation**:

![](https://lh6.googleusercontent.com/VdXssDvsjMc1ExI8vDZ8FDdvd-k1jhVQM0eRWK0eUO8CwX0S1uKW4ssSXSuofDcqMJTZDRmB3KN3s_yKj3JjBU8V8rZquzzKq5hNWuFm6sPtnx7K-PghKZekaG3Lcbt13fas788E)

\
**Simule!**&#x20;

![](/files/-MG-rTOuAMd2rFYdIGmq)

(e lembre-se do comando de mouse **Alt+1º botão do mouse** apertado para mudar o ponto de vista do observador.)

Algumas coisas você mesmo pode fazer para melhorar a qualidade da animação:

* Nas propriedades dos elementos **Path** e **Node**, faça com que esses elementos não apareçam em 3D (vá em **Advanced** e depois escolha a opção **2D only**);

![](https://lh4.googleusercontent.com/Dcy70wKC9nW7wrUBOZGy_6W3gTvLj5f3c7Kk7KKGzdhWvaORNLahMNpavACwwrioeuCYWaQ6busJ1wKT4CYHMHEA7fv5Bq3GEBX8So3Bk1hO4QAjt1atCcPTIuege31OYnaFJb2V)

* Faça um chão para os clientes (desenhe um retângulo preenchido com a textura de **floorWood**. Modifique as propriedades de **Position and size** para que a altura do piso tenha **Z igual a -1** pixel e o **Z-Height** igual a 1);
* Nas propriedades da **3D Window**, escolha uma cor mais clara.

![](https://lh5.googleusercontent.com/ZjvjIiNms4ygg02y8UIv-Oe6U7UBjNlIlpCG5IFNQCC5fck9QhvvHtOazpK3kT2s6-FyeTwaFqLqsC-x-eNNq5tlux9V1yy0rpKYafp0_1N5-vuLN5fAX7ZB92eA4ZXEBrnUhv2y)


# Navegação de agente, funções, objetos etc.

O AnyLogic traz embarcado o [Eclipse](https://pt.wikipedia.org/wiki/Eclipse_\(software\)) e o assistente de conteúdo representado pelo comando **CTRL+Espaço**. Embora para o usuário iniciante (a não ser para aqueles já acostumados com a orientação ao objeto) o recurso pareça ser fácil, este tutorial não versou sobre situações de navegação mais complexas.

O que você precisa entender, na largada, é que navegar entre os objetos de cena utilizando o **ponto final seguido de CTRL+Espaço** seria o mesmo que **navegar pelas pastas de arquivos do seu computador**.&#x20;

Considere o modelo a seguir:

* No agente **Main**, existem duas populações (**companies** e **customers**) e uma função (**announceSale**);
* O tipo de agente da população **companies** é formado pelo agente **Company**;
* Dentro do agente **Company**, nós temos: um bloco **Queue**, uma variável **revenue**, outra população, **employees** formada por agentes do tipo **Employee**.

![](https://lh4.googleusercontent.com/RWrav6wlynOhQPS31TklC1tNZYUJw7fLOZgIYOUkpo97471YuRifMnwfXf-0BmZpu_uUmgZEfNUjJc_XXOkt0-3Z_XDTvJWFuTWbgKmSg9PDoY3mYgFkfcqG0pQYO5xjR2ghdjug)

Por exemplo, o parâmetro **loyalty** (veja no canto superior direito da figura, no agente **Customer**) está “na pasta do” agente **Customer** que, por sua vez, nasce “na pasta **Main**”. Assim como no caso do seu sistema operacional, em que para encontrar um arquivo de uma pasta diferente, você deve voltar a pasta raiz e seguir dali. No AnyLogic, é a mesma coisa.

Se você está dentro do agente **Company** e precisa acessar algo do agente **Customer**, deve primeiro voltar à raiz **Main** e buscar a informação no agente ou população (no caso do exemplo, **customers** é uma população):

![](https://lh5.googleusercontent.com/9-wRJS08uTakI6RHz8Tp2YSyzDmN5jGI0wni8yGksYwL3_U8uZfpBFB879AbXNTJ_S0lHf0K_-uLPIjhVCmkT1Q0u-7BdRqaBz4f6cc1bGnu0wC6M9wc_wGt0jrdWe4ZEP_C0zML)


# Blocos essenciais da paleta Process Modeling Library

![](https://lh5.googleusercontent.com/gi-DrVhh4xkIyqNsOSWOl3gfop8ZCqmRrDk43giXsB_wkWefDdgdZy49RFp3cPBmNNs5uz1RmsMRnf6W-KnQ6GrvkOm9DprgfZTuNKBoQmkko-SsRaENXg6KvOqyxZHtXIsxDLox)

![](https://lh5.googleusercontent.com/W5Gnp7TYhigtcO2jJZZRAwo9EQ56d0bd_W0MnHmTJRCbsFCIwgv-xYJHWbJ3OV3Rz38v-JbU1Nt30Um8wys0GpLhRNgcCbGOWIaA6gZ2SLdhX3yh88U3OyTK_OakrTcrCPdritnd)

![](https://lh3.googleusercontent.com/W2IMcF-hJBd-OKpgGpOV9j96V2SMOiddA3GeUY5l2hu4adRCHEUZsIb4WsY3l1c0Bu3KNIJHkgEKGBDqsT8T1U9zzMVOgYtKSRH0wRzW-mlQ2Px8vEMAphmgb15LppeH8UkxqsWK)


# Timeout e preemption no bloco Queue

Dois recursos comuns nos softwares de simulação são a possibilidade de desistência do agente em fila (**timeout**) e a saída do agente da fila por alguma regra específica de preferência (**preemption**). O bloco **Queue** possui as duas portas de saída já prontas para o usuário identificar qual cliente saiu por qual motivo:

![](https://lh4.googleusercontent.com/5czJfDlQ00i-7AP-KrIx2_Lb4rMRetJ-vfJLJJ_hvORkyIa0hksPb-bxsXXhqUK0-K5sc-Ym_vcgIZMo_KauVogIKvYGUiY1pTIwxPVdivcxr1kR5IVNQyzRO_3oS0AWCoiFHAQZ)

A primeira porta, que equivale à saída por **preemption**, significa que o agente encontrou a fila cheia e, pela regra de preferência, foi extirpado da fila. Note que, para esta opção funcionar, além da opção **Enable preemption** estar ligada, a capacidade da fila deve ser finita.&#x20;

Por exemplo, considere o caixa eletrônico da agência bancária com capacidade de fila de 5 agentes. Se um sexto cliente chegar com interesse em utilizar o caixa eletrônico, ele deveria desistir e ir embora do sistema. O fluxo de processos é relativamente simples neste caso:

![](https://lh3.googleusercontent.com/-iQytu6IBcQwfSxvGLeiUB8o9HH2bSXT22FeOai7YOTlsFqKtviXhUexjK9tlJFAbv5IkMc_brXMqHFVDGs7ypkbBRKOx0MUQq81wOfS72REdp_7Yw7rUD8cG1uX4P_3bdZPxVy_)

Atenção às propriedades do bloco **queue**:

![](https://lh6.googleusercontent.com/iWfDbBRG6xLpt-eBH1BiQgkvRoELQyOMHZeQQojmkinC-H4FKRPPDHHxLki_BL_44SzMuz5eh_ferqB1KSDA8FEEebwRx1YzDobUDc2fS3HUVm86sXT2pt9hZ25rXYtabZHVgXMR)

A segunda porta do bloco **Queue** serve para saída dos agentes que ultrapassaram o tempo máximo de espera especificado. Considere, por exemplo, que na agência bancária, se o cliente aguardar mais do que 15 minutos ele desiste e vai embora. Novamente, o fluxo de processos é bem simples:

![](https://lh3.googleusercontent.com/ZHPmH2FtVU_XmwWlpE4ewLHLZb24eWnGcAVG9O6BDP-wfHz5cozfrJpgkkUD8mmpElDrxXT_8l9Ac4uT3bYTFBEqU07BBoHFl9xFdR_zQNT1Wp8qw04-DMsx-Q-1VL9-tbgjOTdY)

E os parâmetros do bloco **queue** são intuitivos, também:

![](https://lh3.googleusercontent.com/0KDfROIvGPlhi_KvDJ0JaEmiLna1reaoUwhYm2X6trfOTKlFYYrMZ4-cupRbALDvMmxyiotHH7U8k9mQu6DjaB5zrHjprzhuxNKCTE6coCEgz-MHZtqPXBHrTtOD8u2pU5McVpak)


# Resposta do desafio

* Pela teoria das filas (sistema M/M/1), a taxa de chegadas de clientes no caixa eletrônico é de 40% dos clientes que entram no banco, isto é: 0.8 clientes/min (= 40% \* 2.0 clientes/min), a taxa de atendimentos de 2.5 clientes/min (= 1/0.4) e existe apenas um servidor para atendimento. Neste caso, pela aplicação direta das expressões conhecidas para a fila M/M/1:
  * Taxa de ocupação do servidor rho = 0.8/2.5 = 0.32 ou 32%
  * Número médio de elementos no sistema L = rho/(1-rho) = 0.32/(1-0.32) =0.47 clientes
  * Pela fórmula de Little, o tempo médio no sistema de quem utiliza o caixa eletrônico é de W = L/lambda = 0.47/0.8 = 0.59 min;
* Já no sistema de caixas normais, se admitirmos um número suficientemente grande de caixas, ninguém esperaria em fila, mas o tempo de atendimento seria de 5 minutos, dado fornecido pelo problema;
* Como 40% dos clientes dirigem-se ao caixa eletrônico e permanecem 2.0 min no sistema; enquanto 60% dirigem-se aos caixas normais e permanecem 5.0 minutos no sistema, o tempo médio no sistema é calculado diretamente por: 0.4\*0.59 + 0.6\*5.0 = 3.2 min.


# Como citar esta obra e ficha catalográfica (ISBN)

## Como citar

MEDINA, A. C., KIMURA, K; CAVALCANTI, L.; RODRIGUES, R. C., PEREIRA, A. Tutorial AnyLogic: Modelagem de Processos. 1ª edição. São Paulo: Genoa Soluções, 2020. Disponível em: <[https://tutorial.anylogicbrasil.com.br/>](https://tutorial.anylogicbrasil.com.br/>). Data de acesso: \<coloque a data>.

## Ficha catalográfica

Dados Internacionais de Catalogação na Publicação (CIP)

(Câmara Brasileira do Livro, SP, Brasil)

<div align="left"><img src="https://lh5.googleusercontent.com/wgu4cKmXPI9AqdwUQ74qe2JSU_KQrV52Sisq8x58Yd2H2QIukDNQuNQn0S2_UMqRoJLdeQp0gpwvlV8YRhtd6Sq3u-2VLRhMJ3GMYlEdk2weACbUJo4kaMSl_NaqOWXdYtZz-uFM" alt=""></div>