Anylogic 7 em Tres Dias

Ilya Grigoryev
em três dias
Um curso rápido de modelagem de simulação
Segunda edição
2015
2 AnyLogic 7 em Três Dias
ISBN-13: 978-1508933748
ISBN-10: 150893374X
© Copyright 2015 Ilya Grigoryev. Todos os direitos reservados.

Nenhuma parte desta publicação pode ser reproduzida, armazenada em sistemas
de recuperação ou transmitida, em qualquer formato ou por quaisquer meios,
eletrônico, mecânico, fotocopiado, gravado, ou de outro modo, sem a prévia
permissão escrita do autor.
AnyLogic 7 em Três Dias 3
Prefácio
O primeiro livro prático sobre AnyLogic 7 dos desenvolvedores do AnyLogic. O
AnyLogic é o único software de simulação que suporta três métodos de
modelagem de simulação: dinâmica de sistemas, eventos discretos e modelagem
baseada em agentes, e que permite criar modelos multi-método.
O livro está estruturado em torno de quatro exemplos: um modelo de mercado
consumidor, um modelo de epidemia, um modelo de uma pequena fábrica e um
modelo de aeroporto. Também falamos um pouco da teoria sobre os diferentes
métodos de modelagem.
Você pode considerar este livro como o seu primeiro guia no estudo do AnyLogic
7. Lendo o livro e completando os exercícios, você será capaz de criar modelos de
pedestres e eventos discretos usando fluxogramas de processo, desenhar
diagramas de estoque e fluxo e construir modelos baseados em agentes.
Sobre a segunda edição

Se você está familiarizado com a primeira edição do AnyLogic 7 em Três Dias, aqui
estão as principais mudanças:
• Todos os exemplos foram atualizados para atender à última versão do

software, AnyLogic 7.1.2.
• Um novo modelo de fábrica baseado em eventos discretos foi incluído.
Sobre o autor
Ilya Grigoryev é o diretor de serviços de treinamento da AnyLogic, uma empresa
especializada em consultoria e desenvolvimento de softwares de simulação.
Ilya Grigoryev é o autor da documentação do AnyLogic e dos cursos de
treinamento em AnyLogic. Ele já deu treinamentos nos Estados Unidos, Europa,
África e Ásia. Ilya Grigoryev também presta consultoria de simulação para várias
organizações. Ele trabalha na AnyLogic há mais de 10 anos e sabe quase tudo
sobre simulação e AnyLogic.
Agradecimentos
Eu gostaria de agradecer a:
Edward Engel por sua ajuda na escrita do livro e a Anna Klimont por tirar as
imagens.
Todos os líderes de equipe da AnyLogic que tornaram meu tempo na equipe de
desenvolvimento muito agradável: Alexei Filippov, Vasiliy Baranov, George
Meringov e Nikolay Churkov.
Meus colegas e amigos por suas energias positivas: Tatiana Gomzina, Alena
Beloshapko, Evgeniy Zakrevsky (AnyLogic), Vladimir Koltchanov (AnyLogic
Europe), Clemens Dempers (Blue Stallion Technologies) e Derek Magilton
(AnyLogic North America).
Vitaliy Sapounov por seus conselhos e apoio.
Andrei Borshchev por suas contribuições para o livro.
Timofey Popkov e George Gonzalez-Rivas pela ideia de publicar o livro.
Por favor, deixe-me saber como posso melhorar o livro.
Ilya V. Grigoryev
grigoryev@anylogic.com
Conteúdo
Conteúdo ....................................................................................................................................................5
Modelagem de simulação ...................................................................................................................7
Instalando e ativando o AnyLogic ................................................................................................ 15
Modelagem Baseada em Agentes ................................................................................................. 20
Modelo de mercado ....................................................................................................................... 23
Fase 1. Criando a população de agentes ............................................................................... 23
Fase 2. Definindo o comportamento consumidor............................................................ 42
Fase 3. Adicionando um gráfico para visualizar os resultados do modelo ........... 54
Fase 4. Adicionando o efeito boca a boca ............................................................................ 66
Fase 5. Considerando os descartes do produto ................................................................ 72
Fase 6. Considerando o tempo de entrega .......................................................................... 75
Fase 7. Simulando a impaciência do consumidor ............................................................ 81
Fase 8. Comparando execuções do modelo com valores de parâmetros
diferentes ........................................................................................................................................... 93
Modelagem de Dinâmica de Sistemas ..................................................................................... 101
O modelo SEIR .............................................................................................................................. 103
Fase 1. Criando um diagrama de estoque e fluxo .......................................................... 103
Fase 2. Adicionando um gráfico para visualizar a dinâmica .................................... 115
Fase 3. Experimento de variação de parâmetros .......................................................... 120
Fase 4. Experimento de calibração ...................................................................................... 129
Modelagem de eventos discretos .............................................................................................. 135
Modelo de Fábrica ....................................................................................................................... 137
Fase 1. Criando um modelo simples ................................................................................... 137
Fase 2. Adicionando recursos ................................................................................................ 151
Fase 3. Criando animações 3D ............................................................................................... 158
Fase 4. Modelando a entrega de paletes por caminhões............................................ 169
Modelagem de Pedestres .............................................................................................................. 191

Modelo de aeroporto ................................................................................................................. 192
Fase 1. Definindo o fluxo de pedestres básico ............................................................... 193
Fase 2. Desenhando animações 3D ..................................................................................... 204
Fase 3. Adicionando pontos de inspeção de segurança ............................................. 208
Fase 4. Adicionando as instalações de check-in ............................................................ 215
Fase 5. Definindo a lógica de embarque ........................................................................... 225
Fase 6. Configurando voos do Excel .................................................................................... 233
Referências ......................................................................................................................................... 256
Índice ..................................................................................................................................................... 258
Modelagem de simulação
A modelagem é uma forma pela qual podemos resolver problemas do mundo real.
Em muitos casos, não podemos arcar com experimentos com objetos reais para
encontrar as soluções certas: construir, destruir e fazer alterações pode ser muito
caro, perigoso ou simplesmente impossível. Se esse for o caso, podemos construir
um modelo que use uma linguagem de modelagem para representar o sistema
real. Este processo assume abstrações: incluímos os detalhes que acreditamos que
sejam importantes e deixamos de lado aqueles que não são. O modelo sempre
será menos complexo do que o sistema original.
Modelagem
 As fases de construção do modelo – mapeamento do mundo real para o

mundo dos modelos, escolha do nível de abstração e da linguagem de
modelagem – são todas menos formais do que o processo de usar modelos

para resolver problemas. Isso ainda é mais uma arte do que uma ciência.
Depois de construirmos o modelo – e, às vezes, quando estamos construindo –

podemos começar a explorar e entender o comportamento e a estrutura do
sistema, testar como ele se comportará sob diversas condições, executar,
comparar cenários e otimizar. Depois de encontrarmos a solução, podemos
mapeá-la para o mundo real.
 A modelagem consiste em encontrar o caminho do problema para a solução

através de um mundo livre de riscos, onde é permitido cometer erros,
desfazer, voltar e recomeçar novamente.
Tipos de modelos
Há vários tipos de modelos, incluindo os modelos mentais que usamos para
entender como tudo funciona no mundo real: os amigos, a família, os colegas, os
motoristas, a cidade onde vivemos, as coisas que compramos, a economia, os
esportes e a política. Todas as nossas decisões – o que devemos dizer para o filho,
o que devemos comer no café da manhã, em quem devemos votar ou onde
devemos levar a namorada para jantar – são baseadas em modelos mentais.
Os computadores são poderosas ferramentas de modelagem, eles nos
proporcionam um mundo virtual flexível onde podemos criar quase qualquer
coisa imaginável. Claro, há muitos tipos de modelos computacionais, de planilhas
que permitem modelar gastos até ferramentas complexas de modelagem de
simulação que ajudam usuários avançados a explorar sistemas dinâmicos, como
mercados consumidores e campos de batalha.
Modelagem analítica vs. modelagem de simulação

Pergunte a equipes de planejamento estratégico, previsão de vendas, logística,
marketing ou gerenciamento de projetos de uma grande organização o nome da
ferramenta de modelagem favorita deles, e rapidamente descobrirá que Excel é a
resposta mais popular. O Excel tem algumas vantagens: ele é muito utilizado, fácil
de usar e permite adicionar scripts às fórmulas, na medida em que a lógica da
planilha for se tornando sofisticada.
Calcular!
Entradas Saídas
X1 Y1
X2
X3 Y = f(X) Y2
Y3
X4 Fórmulas e scripts
Y4
Modelo Analítico (A planilha do Excel)
A tecnologia por trás da modelagem baseada em planilhas é simples: você digita

os dados de entrada em algumas células e visualiza os dados de saída em outras.
As fórmulas – e em modelos mais complexos, os scripts – conectam os valores de
entrada aos de saída. Várias extensões permitem realizar variações de
parâmetros, métodos de Monte Carlo ou experimentos de otimização.
Contudo, há também uma grande classe de problemas onde a solução analítica
(baseada em fórmulas) é difícil de ser encontrada ou simplesmente não existe.
Esta classe inclui os sistemas dinâmicos que têm como características:
• Comportamento não-linear
• "Memória"
• Influência não intuitiva entre variáveis
• Dependência causal e temporal
• Todas acima, combinadas com incerteza e um grande número de parâmetros

Na maioria dos casos, é impossível obter as fórmulas exatas, muito menos
organizar um modelo mental de tais sistemas.
Considere um problema que requeira otimizar uma frota de trens ou caminhões. É
difícil usar uma planilha Excel para gerenciar fatores como horários de viagens,
tempos de carga e descarga, restrições de tempo de entrega e capacidades dos
terminais. A disponibilidade de um veículo, em um certo local, data e hora,
depende da sequência de eventos anteriores, e determinar para onde enviar o
veículo quando ele está ocioso requer analisar a sequência de eventos futuros.
 As fórmulas são boas em expressar dependências estáticas entre variáveis,

mas, geralmente, não são boas em descrever sistemas com comportamento
dinâmico. Por isso, usamos outra tecnologia de modelagem – a modelagem
de simulação – para analisar sistemas dinâmicos.
Um modelo de simulação é sempre um modelo executável: sua execução cria uma

trajetória das mudanças de estado do sistema. Pense em um modelo de simulação
como um conjunto de regras que dizem como ir do estado atual do sistema para
um estado futuro. As regras podem tomar várias formas, incluindo equações
diferenciais, diagramas de estados, fluxogramas de processo e cronogramas. As
saídas do modelo são produzidas e observadas em tempo de execução.
A modelagem de simulação requer softwares especiais que usem linguagens
específicas de simulação. Embora seja preciso treinamento para construir bons
modelos de simulação, o tempo e o esforço preciso são recompensados quando o
seu modelo oferece uma análise de alta qualidade de um sistema dinâmico.
Muitas pessoas – especialmente as que sabem bem Excel ou que têm experiência
em programação – usam planilhas para modelar sistemas dinâmicos. À medida
que capturam mais detalhes, inevitavelmente, começam a reproduzir a
funcionalidade de simuladores do Excel. Os modelos resultantes são lentos e
difíceis de manipular e, geralmente, são descartados rapidamente.
É virtualmente impossível capturar um detalhe em uma solução analítica. Ainda
que houvesse fórmulas para guiar a configuração, até mesmo processos pequenos
poderiam anulá-las, e você iria precisar de um matemático para ajustá-las.
Vantagens da modelagem de simulação

A modelagem de simulação tem seis vantagens principais:
1. Modelos de simulação permitem analisar sistemas e encontrar soluções
onde métodos como cálculos analíticos e programação linear falham.
2. Uma vez escolhido o nível de abstração, é mais fácil desenvolver um
modelo de simulação do que um modelo analítico. Ele normalmente exige
menos atenção e o processo de desenvolvimento é escalável, incremental
e modular.
3. A estrutura de um modelo de simulação naturalmente reflete a estrutura
do sistema.
4. Em um modelo de simulação, você pode medir valores e rastrear

entidades dentro do nível de abstração, e pode adicionar medições e
análises estatísticas a qualquer hora.
5. A capacidade de executar e animar o comportamento do sistema no
tempo é uma das grandes vantagens da simulação. Você verá que a
animação é útil para demonstração, verificação e depuração.
6. Modelos de simulação são muito mais convincentes do que planilhas
Excel. Se você usa uma simulação para apoiar sua proposta, você terá
uma vantagem maior sobre aqueles que apenas usam números.
Aplicações de modelagem de simulação

A modelagem de simulação vem acumulando um grande número de histórias de
sucesso, em uma gama de áreas de aplicação. À medida que novos métodos e
tecnologias de modelagem surgem, e o poder computacional aumenta, espera-se
que a modelagem de simulação entre em um número ainda maior de áreas.
Nível de abstração Grupos, ciclos de retroalimentação, influências de alto

alto nível, …
(poucos detalhes,
nível macro,  Sistemas sociais  Ecosistema  Economia
nível estratégico)  Mercado e concorrência
 Gerenciamento de  Recursos humanos

projetos
 Gerenciamento de frotas
 Cadeias de suprimento
Nível de abstração  Transportes  Centrais de
médio atendimento
 Processos de negócio
(alguns detalhes,  Terminais multimodais
nível meso,  Armazéns
nível tático)  Aeroportos  Hospitais
 Pátios ferroviários  Fábricas
 Campo de batalha Trânsito (microscópico)


Nível de abstração
baixo  Circulação de pedestres
(muitos detalhes,  Hardware de computador  Sistemas de controle
nível micro, Objetos isolados, tamanhos exatos, velocidades, distâncias,
nível operacional) tempo…
Aplicações de simulação
A figura acima mostra várias aplicações de simulação, organizadas pelo nível de

abstração dos modelos correspondentes.
Na parte inferior estão os modelos de nível físico que utilizam representações

muito detalhadas dos objetos do mundo real. Neste nível, nos preocupamos com
as interações físicas, dimensões, velocidades, distâncias e tempos. O freio ABS de
um automóvel, a evacuação de fãs de futebol de um estádio, o tráfego em um
cruzamento com semáforos e ações de soldados em campos de batalha são
exemplos de problemas que requerem modelagens de nível de abstração baixo.
Os modelos da parte superior são os mais abstratos, normalmente usam
conjuntos como populações de consumidores e estatísticas de emprego no lugar
de objetos isolados. Desde que seus objetos interajam em alto nível, eles podem
nos ajudar a entender relacionamentos – como o dinheiro que uma empresa
investe em propaganda influencia nas vendas – sem precisar modelar os passos
intermediários.
Outros modelos têm um nível de abstração intermediário. Se modelarmos a
emergência de um hospital, podemos nos preocupar apenas com o espaço físico,
se quisermos saber quanto tempo leva para alguém andar da sala de emergência
para a sala de raios-X, pois a interação física entre as pessoas é irrelevante porque
assumimos que a emergência não está lotada.
Em um modelo de processos de negócio ou em uma central de atendimento,
podemos modelar a sequência e a duração das operações, além de suas
localizações. Em um modelo de transportes, consideramos cuidadosamente a
velocidade do caminhão ou do trem, mas em um modelo de uma cadeia de
suprimentos de alto nível, simplesmente assumimos que um pedido leva entre
sete e dez dias para chegar.
 Escolher o nível de abstração certo é crítico para o sucesso do seu projeto de

modelagem, e você descobrirá que isso é razoavelmente fácil uma vez que
tenha decidido o que quer incluir e o que ficará de fora do nível de abstração.
 No processo de desenvolvimento do modelo, é normal – até mesmo

desejável – de vez em quando, reconsiderar o nível de abstração do modelo.
Na maioria dos casos, você iniciará em um nível de abstração alto e
adicionará detalhes na medida que precisar.
Os três métodos de modelagem de simulação

As modelagens de simulação modernas usam três métodos: eventos discretos,
modelagem baseada em agentes e dinâmica de sistemas.
Nível de abstração Grupos, ciclos de retroalimentação, influências de

alto alto nível, …
(poucos detalhes,
nível macro, DS
nível estratégico)
BA Dinâmica de
Sistemas
Nível de abstração
médio
(alguns detalhes,
nível meso,
ED
nível tático)
Modelagem
de eventos
Nível de abstração discretos
(centrada em Modelagem
baixo baseada em
(muitos detalhes, processos)
agentes
nível micro,
nível operacional) Objetos isolados, tamanhos exatos, velocidades, distâncias,
tempo…
Métodos de modelagem de simulação
Em modelagem de simulação, um método é uma estrutura que usamos para

mapear um sistema do mundo real para seu modelo. Você pode pensar em um
método como um tipo de linguagem ou um tipo de "termos e condições" para a
construção do modelo. Existem três métodos:
• Dinâmica de Sistemas
• Eventos Discretos
• Modelagem Baseada em Agentes

Cada método se aplica a uma gama específica de níveis de abstração. A dinâmica
de sistemas pressupõe um nível de abstração alto e é normalmente usada para
modelagem estratégica. Eventos discretos suportam abstrações de níveis médio e
baixo. No meio, estão os modelos baseados em agentes, que podem variar de
modelos muito detalhados, onde agentes representam objetos físicos, a modelos
altamente abstratos, onde agentes são empresas ou governos concorrentes.
Você deve sempre selecionar o método depois de considerar cuidadosamente o
sistema que quer modelar e os seus objetivos. Na figura abaixo, o problema do
modelador determinará como modelar um supermercado. Ele poderia construir
um fluxograma de processo, onde clientes são entidades e funcionários são
recursos; um modelo baseado em agentes, onde clientes são agentes que são
influenciados pela propaganda, comunicação e suas interações com agentes e

funcionários; ou uma estrutura de retroalimentação, onde as vendas estão no
ciclo de anúncios, qualidade de serviço, preço e fidelidade do cliente.
Estoques, fluxos,
retroalimentação ? Entidades, recursos,
operações ? Agentes, regras de
comportamento, ?
interação
Propaganda Chegadas Escolha de Anúncios
produtos
Fidelidade
Clientes
Vendas Registro Saída
Preço Caixas Funcionários
O Modelador
Você também pode descobrir que a melhor forma de modelar as diferentes partes
de um sistema é usando métodos diferentes e, nessas situações, um modelo multi-
método atenderá melhor as suas necessidades (Borshchev, 2013).
Instalando e ativando o AnyLogic

O processo de instalação do AnyLogic 7 Professional é simples e prático. Baixe o
AnyLogic 7 em www.anylogic.com e depois use os passos a seguir para instalá-lo:
1. Inicie o AnyLogic. Se ele ainda não estiver ativado com a chave de
desbloqueio, o AnyLogic Activation Wizard será exibido automaticamente.
2. Na página Activate AnyLogic, escolha Request a time-limited Evaluation Key.
The key will be sent to you by e-mail e depois clique em Next.
3. Na página AnyLogic License Request, preencha suas informações pessoais e

depois clique em Next.
Você receberá uma confirmação logo depois que enviar o formulário, e

receberá a chave de avaliação em um e-mail separado.
4. Depois que receber a chave de ativação, abra o assistente de ativação do

AnyLogic, escolha Enter the Evaluation Key that you received by email, na
primeira página, e depois clique em Next.
5. Copie a chave de ativação da mensagem de e-mail que você recebeu e cole-a

no campo Please paste the key here. Em seguida, clique em Next.
6. Você deve ver uma mensagem que diz que o produto foi ativado com sucesso.
7. Clique em Finish.
Você completou o processo de ativação do AnyLogic e pode começar a
desenvolver o seu primeiro modelo.
Modelagem Baseada em Agentes

A modelagem baseada em agentes é um método relativamente novo, comparado a
modelagem de eventos discretos e a dinâmica de sistemas. De fato, a modelagem
baseada em agentes era um assunto acadêmico até que os profissionais da área de
simulação começaram a usá-la, há cerca de 15 anos.
Ela foi desencadeada por:
• Um desejo de ganhar uma visão mais aprofundada dos sistemas, que as

abordagens tradicionais não capturam bem
• Avanços na tecnologia de modelagem, possíveis graças à ciência da

computação, como orientação a objetos, UML e diagramas de estados
• O rápido crescimento de potência da CPU e da memória. Modelos

baseados em agentes demandam mais do que dinâmica de sistemas e
eventos discretos.
A modelagem baseada em agentes dá ao modelador outra forma de ver o sistema:
 Você pode não saber como se comporta um sistema, ser capaz de identificar
suas principais variáveis e dependências ou reconhecer um fluxo de
processo, mas você pode ter noções de como os objetos do sistema se
comportam. Se este for o caso, você pode começar a construir o modelo
identificando os objetos (agentes) e definindo os seus comportamentos.
Depois, você pode conectar os agentes criados e possibilitar que interajam
entre si, ou colocá-los em um ambiente que tenha a sua própria dinâmica. O
comportamento global do sistema surge de muitos (dezenas, centenas,
milhares, milhões) comportamentos individuais concorrentes.
Não existe uma linguagem padrão para a modelagem baseada em agentes, a sua
estrutura vem de editores gráficos ou scripts. Há várias formas de especificar o
comportamento de um agente. Geralmente, o agente tem uma noção de estado e
suas ações e reações dependem desse estado; assim, o comportamento é mais
bem definido com diagramas de estados. Às vezes, o comportamento é definido
por regras, executadas por eventos especiais.
Em muitos casos, a melhor forma de capturar a dinâmica interna do agente é usar
dinâmica de sistemas ou uma abordagem de eventos discretos, e assim colocar
um diagrama de estoque e fluxo ou um fluxograma de processo dentro do agente.

Da mesma forma, agentes externos à dinâmica do ambiente são muitas vezes
modelados com métodos tradicionais. É por isso que muitos modelos baseados
em agentes são modelos multi-método.
Os agentes em um modelo baseado em agentes podem representar diversas
coisas: veículos, peças de equipamento, projetos, produtos, ideias, organizações,
investimentos, lotes de terra, pessoas em diferentes papéis, etc.
Pessoas em diferentes papéis: Equipamentos, veículos:

consumidores, cidadãos, funcionários, caminhões, carros, gruas,
pacientes, doutores, clientes, soldados, … aviões, vagões, máquinas, …
Coisas abstratas: Organizações:

projetos, produtos, inovações, empresas, partidos políticos, países, …
ideias, investimentos …
Pesquisadores ainda debatem sobre quais propriedades um objeto deve ter para
ser um “agente”: características proativas e reativas, percepção espacial,
capacidade de aprender, capacidade social, “intelectual”, etc. Em modelagem
baseada em agentes aplicada, entretanto, você encontrará todo tipo de agente:
alguns se comunicam enquanto outros vivem em isolamento total, alguns vivem
em um espaço enquanto outros vivem sem, e alguns aprendem e se adaptam
enquanto outros nunca mudam seus comportamentos padrões.
Aqui estão alguns fatos úteis que garantem que você não está mal orientado pela
literatura ou pelas várias teorias de modelagem baseada em agentes:
• Agentes não são autômatos. Agentes não precisam viver em um espaço

discreto (como a grade do Jogo da Vida, ("The Game of Life", s.d.)), e o espaço
não faz parte de muitos modelos baseados em agentes. Quando você precisar
representar espaço, normalmente, ele é contínuo, como um mapa ou as
instalações de uma planta baixa.
• Agentes não são necessariamente pessoas. Qualquer coisa pode ser um

agente: um veículo, uma peça de equipamento, um projeto, uma ideia, uma
organização ou até mesmo um investimento. Um modelo de fábrica de
transformação de aço, onde cada máquina é modelada como um agente e suas
interações produzem aço, forma um modelo baseado em agentes.
• Um objeto que parece ser totalmente passivo pode ser um agente. Você
pode modelar uma tubulação em uma rede de fornecimento de água como um
agente e depois associar cronogramas de manutenção e troca, custos e
eventos de deterioração a ela.
• Um modelo baseado em agentes pode ter muitos ou poucos agentes. O

modelo pode ter também um ou vários tipos de agentes.
• Existem modelos baseados em agentes onde os agentes não interagem.

A economia da saúde, por exemplo, utiliza o uso do álcool, obesidade e
modelos de doenças crônicas onde a dinâmica individual depende somente
dos parâmetros pessoais e, algumas vezes, do ambiente.
Modelo de mercado
Construiremos um modelo baseado em agentes de um mercado consumidor –
onde cada consumidor será um agente – para nos ajudar a entender como um
produto entra no mercado. Uma vez que as decisões humanas sempre incluem
eventualidades, a modelagem baseada em agentes é ideal para simulações de
mercados.
Vamos assumir o seguinte:
• O modelo inclui 5.000 pessoas que não usam o produto, mas uma
combinação de propaganda e marketing boca a boca levarão as pessoas a
comprá-lo eventualmente.
Fase 1. Criando a população de agentes

Começaremos criando um modelo simples que descreve como a propaganda leva
os consumidores a comprar nosso produto.
Os consumidores do nosso modelo não usarão o produto de primeira, mas todos
eles estão potencialmente interessados em usá-lo. Nós também representaremos
a influência da propaganda na demanda do consumidor, possibilitando que uma
porcentagem específica deles se torne interessada em comprar o produto em um
certo dia. Para o nosso propósito, Advertising effectiveness = 0.1 determina a
porcentagem de usuários potenciais que estão prontos para comprar o produto
em um determinado dia.
Inicialize o AnyLogic e a página Welcome será exibida.
A página Welcome apresenta o AnyLogic a você, oferece uma visão geral do
programa e suas características, e permite abrir modelos de exemplo.
Página Welcome
1. Feche a página Welcome e crie um novo modelo selecionando File > New >
Model no menu principal do AnyLogic. O assistente New Model abrirá.
2. No campo Model name, digite o nome do novo modelo: Market.

3. No campo Location, selecione o diretório onde você quer criar o modelo. Você
pode navegar pelo diretório clicando em Browse ou digitar o nome do
diretório que você quer criar no campo Location.
Agora, vamos revisar brevemente a interface do AnyLogic.
Projects e Palette.
Clique na aba para mudar de visão
Visão Properties
Editor gráfico
Área de trabalho do AnyLogic

• O editor gráfico permite editar o diagrama do agente, e você pode adicionar
elementos do modelo arrastando-os da Palette para o diagrama e colocando-
os no canvas do editor. Os elementos colocados no frame azul aparecerão na
janela do modelo, quando ele for executado.
• A visão Projects permite acessar os modelos abertos na área de trabalho, e a

árvore de projetos ajuda a navegar facilmente por eles.
• A visão Palette lista os objetos agrupados em paletas. Para adicionar um

elemento ao seu modelo, arraste-o do Palette para o editor gráfico.
• A visão Properties permite visualizar e modificar as propriedades do item

selecionado.
• Para abrir/fechar uma visão, escolha o item correspondente no menu View. Se

o item for selecionado, a visão correspondente se tornará visível.
• Para redimensionar uma visão, use o mouse para arrastar a borda da visão.
• Você pode sempre usar a opção Reset perspective do menu Tools para retornar
as visões para as posições padrões.
5. Vamos abrir a visão Projects para examinar a estrutura do modelo. Você

encontrará as visões Palette e Projects no lado esquerdo da área de trabalho,
e poderá mudar da visão Palette para Projects clicando na aba Projects.
Navegando pelo modelo na visão Projects

• A visão Projects permite acessar os projetos do AnyLogic abertos na área
de trabalho. Você poderá usar a árvore para navegar por eles de forma
rápida e fácil.
• O AnyLogic usa uma

estrutura em árvore para
exibir seu modelo. O
primeiro nível mostra o
modelo, o segundo nível
mostra os tipos de agentes e
os experimentos e o terceiro
nível organiza os elementos
que formam a estrutura do
agente.
• Por padrão, um modelo tem um tipo de agente – Main – e um experimento

Simulation. Um clique duplo no tipo de agente ou experimento abre seus
diagramas no editor gráfico.
• Clicando no elemento do modelo na árvore, ele é selecionado e

centralizado no editor gráfico. Isto pode ser útil quando você não
conseguir encontrar o elemento no diagrama.
No editor gráfico, você verá o diagrama do agente Main vazio.
Agentes
• Os agentes são blocos de construção de um modelo, e você pode usá-los para
modelar todo tipo de objeto do mundo real, incluindo organizações,
empresas, caminhões, estações de processamento, recursos, cidades,
revendedores, objetos físicos, controladores, entre outros.
• Cada agente normalmente representa uma das seções lógicas do modelo. Isto
permite decompor um modelo em vários níveis de detalhe.
Nosso modelo tem um tipo de agente, Main. Para adicionar os consumidores,
precisaremos criar um tipo de agente que represente os consumidores, e
depois criar uma população de agentes composta de instâncias deste tipo de
agente consumidor. No AnyLogic 7, você pode usar o assistente New agent
para criar os agentes.
6. Nós queremos adicionar um novo elemento ao modelo, mas primeiro
precisamos mudar para a visão Palette, clicando na aba Palette.
7. Abra a paleta Agent. Para abrir uma paleta específica, vá na visão Palette e
passe o mouse sobre o painel de navegação vertical da visão.
8. Ele se expandirá mostrando o nome de todas as paletas para que você possa
selecionar a que precisa. Clique na paleta Agent na lista para selecioná-la.
Uma vez que estiver familiar com os ícones, você pode clicar no ícone da paleta
que desejar na barra de navegação.
9. Arraste o Agent da paleta Agent para o diagrama Main, e o assistente New
agent abrirá.
9
10. No Passo 1, página Choose what you want to create, selecione a opção que
melhor atende as suas necessidades. Como queremos criar múltiplos agentes
do mesmo tipo, selecione Population of agents e clique em Next.
10
11. No Passo 2, página Creating new agent type, no campo Agent type name,
digite Consumer. O conteúdo do campo Agent population name
automaticamente mudará para consumers.
11
12
12. Clique em Next.

13. Na página Agent animation, escolha a forma de animação do agente. Como

estamos criando um modelo simples que usa animação 2D, escolha 2D,
selecione o primeiro item da lista General: Person e clique em Next.
13
14. Na página Agent Parameters, defina os parâmetros ou as características do

agente.
Como nosso modelo considera apenas compras de produtos relacionados à
propaganda, adicionaremos um parâmetro – AdEffectiveness – para definir a
porcentagem de usuários potenciais que estão prontos para comprar o produto
em um determinado dia.
15
16
15. Na seção à esquerda, na tabela Parameters, clique em <add new…> para criar
um parâmetro.
16. No campo Parameter, altere o nome padrão do parâmetro para
AdEffectiveness, e escolha double como Type do parâmetro. Assumiremos que
uma média de 1% dos usuários potenciais do nosso modelo desejará comprar
o produto durante determinado dia, então especifique 0.01 como o valor do
parâmetro.
17. Clique em Next.
18. Na página Population size, digite 5000 no campo Create population with …
agents para criar 5.000 instâncias do tipo Consumer. Cada instância da
população modelará um agente consumidor específico.
Embora tenhamos criado a nossa população de agentes, não veremos 5,000
figuras de animação Person no diagrama Main. Ao invés disso, o AnyLogic
usará os 5,000 agentes da população consumers para simular o mercado
quando executarmos o modelo.
19. Clique em Next.

20. Na página Configure new environment, mantenha os valores padrões para o

tipo de espaço do ambiente (Continuous) e para Width e Height (500). O
AnyLogic mostrará os agentes em um retângulo de 500x500 píxeis.
21. Marque o campo Apply random layout para distribuir aleatoriamente os
agentes através da área de 500x500 píxeis que definimos. Como não
queremos criar uma rede de agentes, manteremos o tipo de rede padrão
como No network/User-defined.

23. Vamos usar a visão Projects para ver os novos elementos que o assistente
criou. Expanda a árvore do modelo para ver os detalhes internos.
Nosso modelo agora tem dois tipos de agentes: Main e Consumer.
• O tipo de agente Consumer tem uma forma de animação de agente

(person, no ramo Presentation) e o parâmetro AdEffectiveness.
• O tipo de agente Main contém a população de agentes consumers (um

conjunto de 5,000 agentes do tipo Consumer).
Ambiente do agente
O agente Main atua como ambiente para a população consumers. Como o ambiente
define o espaço, o layout, a rede e a comunicação que nossos agentes usam,
precisaremos de um ambiente para organizar as apresentações dos agentes e
modelar a propaganda “boca a boca” que acontece quando nossos agentes
interagem entre si.
24. Clique em Main, em Projects, para abrir suas propriedades na visão Properties
(você encontrará Properties na metade direita da janela do AnyLogic).
Na seção Space and network das propriedades de Main, você pode ajustar as
configurações do ambiente para a população de agentes consumers.
A visão Properties
• A visão Properties é uma visão
sensível ao contexto das
propriedades do elemento.
• Para modificar as propriedades de

um elemento, selecione o
elemento no editor gráfico ou na
visão Projects, e depois use a visão
Properties para modificar as
propriedades.
• A visão Properties tem várias

seções. Para expandir ou retrair
uma seção, clique em seu título.
• O nome e o tipo do elemento

selecionado são exibidos no topo
da visão.
25. No diagrama Main, selecione a forma de animação composta e não editável da

população de agentes , abra a seção de propriedades Advanced, e marque a
opção Draw agente with offset to this position.
25
Como você pode ver na figura a seguir, a forma de animação define o canto
superior esquerdo de área 500x500 píxeis onde os agentes ficarão quando
executarmos o modelo.
Acabamos de construir este modelo simples, e agora você pode executá-lo e

observar o seu comportamento.
26. Na barra de ferramentas, clique no botão Build para construir o modelo e

verificar se existem erros.
27. Localize o botão Run e clique no triângulo pequeno à direita. Selecione

o experimento que você quer executar. Escolha Market / Simulation na lista.
27
Como você pode ter muitos modelos abertos ao mesmo tempo – e cada modelo
pode ter vários experimentos – você deve selecionar o experimento correto.
Depois que você inicializa o modelo, a janela de apresentação mostra o
experimento lançado Simulation . Por padrão, a janela de apresentação exibe o
nome do modelo e o botão Run.
28. Clique no botão Run para executar o modelo.
28
Você verá a apresentação do modelo (a apresentação que você criou para o agente
Main) que mostra as 5,000 animações dos agentes que formam a população de
consumers. Como não criamos nenhum comportamento para nossos agentes, a
animação aparece imóvel.
Barra de status da janela do modelo

• Para ter certeza que o modelo está sendo executado, olhe para a barra de
status na parte inferior da janela do modelo:
• A barra de status exibe o status de simulação do modelo (Running, Paused,

Idle ou Finished), o tempo do modelo atual, a data do modelo, etc.
• Você pode personalizar a barra de status clicando no botão , e escolher as

seções de interesse na lista que aparece.
Você pode usar a barra de ferramentas da parte superior da janela de

apresentação do AnyLogic para controlar a execução do modelo.
Controlando a execução do modelo

Run from the current state
[Visível quando o modelo não está em execução] Inicia a simulação ou, se

a simulação foi pausada, reinicia.
Step
Executa um evento do modelo e, em seguida, pausa sua execução.

Pause
[Visível quando o modelo está em execução] Pausa a simulação. Você

pode recomeçar uma simulação pausada a qualquer momento.
Terminate execution
Termina a execução do modelo atual.

29. Estamos prontos para definir a lógica do consumidor. Para continuar
desenvolvendo nosso modelo, feche a janela de apresentação.
29
Fase 2. Definindo o comportamento consumidor

Continuaremos a desenvolver o modelo definindo o comportamento e as
características do consumidor. A melhor forma de definir um comportamento é
usar um diagrama de estados.
Diagramas de estados
• Os diagramas de estados são as estruturas mais avançadas para descrever
comportamentos baseados em eventos e no tempo. Para alguns objetos, esta
ordem evento-temporal das operações é tão comum que você pode melhor
caracterizar seu comportamento usando um diagrama de transição de
estados – um diagrama de estados.
• Os diagramas de estados têm estados e transições. Os estados do diagrama

são alternativos, isso significa que o objeto pode estar somente em um
estado de cada vez. Uma execução de transição pode levar a uma mudança de
estado que torna um novo conjunto de transições ativo. Os estados do
diagrama podem ser hierárquicos – eles podem conter outros estados e
transições.
• Um agente pode ter vários diagramas de estados que descrevem partes

independentes do comportamento do agente.
Definiremos o comportamento do consumidor como uma sequência de dois

estados:
• Um consumidor no estado PotentialUser está apenas potencialmente

interessado em comprar o produto.
• Um consumidor no estado User, comprou o produto.

1. Na visão Projects, abra o diagrama Consumer com um clique duplo nele. Você
verá o diagrama gráfico do agente com o parâmetro e a figura de animação na
origem dos eixos.
Como você sabe que tipo de agente está editando?

Como nosso modelo tem dois tipos de agentes, você pode questionar que tipo de
agente está editando no editor gráfico.
• O AnyLogic seleciona a aba do tipo de agente que você abriu no editor

gráfico e destaca seu item na árvore de Projects (veja a figura abaixo).
• Você pode navegar entre os diagramas gráficos abertos dos tipos

diferentes de agente ao clicar nas abas (por exemplo, Main e Consumer no
exemplo abaixo):
2. Comece desenhando um diagrama de estados com dois estados. Abra a paleta

Statechart.
3. Arraste o Statechart Entry Point da paleta Statechart para o diagrama

Consumer. Você começa a desenhar um diagrama de estados adicionando um
statechart entry point. O ponto de entrada define o início do fluxo de controle
do diagrama de estados e o nome do diagrama.
 Por favor, preste atenção – é fácil confundir o Statechart Entry Point com o
Initial State Pointer, ou uma Transition, uma vez que eles são parecidos.
Você pode ver como o AnyLogic destacou o statechart entry point em vermelho.
Isso significa que o ponto de entrada não está conectado a um estado, e que o
diagrama de estados atual é inválido.
Vamos adicionar o primeiro estado ao diagrama de estados do consumidor.
4. Arraste o State da paleta Statechart para o diagrama gráfico, e conecte-o ao
ponto de entrada do diagrama.
 Certifique-se de que você está desenhando o diagrama de estados no

diagrama Consumer e não no diagrama Main.
5. Selecione o estado no editor gráfico e modifique suas propriedades. Nomeie o

estado como PotentialUser.
6. Use o campo Fill color para alterar a cor do estado para lavander.
7. Digite o seguinte código Java no campo Entry action do estado:

shapeBody.setFillColor(lavender)
Assistente de autocomplemento de código

• Você pode usar o assistente de autocomplemento de código para evitar digitar
nomes completos de elementos e funções. Para abrir o assistente, clique na
posição desejada do campo de edição e pressione Ctrl+espaço (Alt+espaço no
Mac OS). A janela que aparece lista os elementos do modelo que estão
disponíveis no contexto dado, como as variáveis, parâmetros ou funções do
modelo.
• Vá até o nome do elemento que deseja adicionar, ou digite as primeiras letras

do elemento até que ele apareça na lista, e pressione Enter para inserir o
nome do elemento no campo de edição.
A Entry action é executada quando o

consumidor mudar de estado. Este
código exibe a mudança de estado
trocando a cor da animação do
consumidor.
Aqui, shapeBody é o nome da forma de
animação do consumidor que o
assistente new agent criou. (Se você
expandir o ramo Presentation do
Consumer na árvore Projects, você verá
a forma shapeBody dentro do grupo
person).
Aqui chamamos a função de shapeBody. Para acessar a função do elemento, digite

o nome do elemento (shapeBody), digite um ponto, e depois use a funcionalidade
de autocomplemento de código para listar as funções do elemento ou selecionar o
nome da função na lista. setFillColor() é uma das funções padrões de forma que
permite mudar dinamicamente a cor de preenchimento da forma. Ela tem apenas
um argumento – uma nova cor.
8. Adicione outro estado ao diagrama de estados do consumidor:
9. Modifique as propriedades do estado como você fez anteriormente:

Name: User
Fill color: yellowGreen
Entry action: shapeBody.setFillColor(yellowGreen);
10. Desenhe uma transição do estado PotentialUser para o estado User para
modelar como as pessoas compram o produto e se tornam usuárias. Para
fazer isso, dê um clique duplo no elemento Transition (o ícone da paleta do
elemento deve mudar para ) da paleta statechart, clique no estado
PotentialUser, e clique em User .
 Certifique-se de que a transição está conectada aos estados. Se a transição

não estiver conectada, o AnyLogic a destaca em vermelho.
11. Nomeie a transição como Ad para representar os “anúncios”.

12. Marque o checkbox Show name para exibir o nome da transição no diagrama
gráfico.
13. A transição do estado PotentialUser para User modelará como a propaganda
leva a pessoa a comprar o produto. Na lista Triggered by, clique em Rate. No
campo Rate, digite AdEffectiveness, e depois clique em per day.
Você pode ver que o ícone desenhado sobre a transição mudou de para .
Este sinal indica o tipo de gatilho da transição.
Para mover o nome ou o ícone da transição, selecione a transição, e use o mouse
para arrastar o elemento correspondente para uma nova posição.
Tipos de gatilhos de transição

Muitos tipos de eventos podem acionar uma transição. A tabela a seguir lista os
tipos de gatilhos de transição bem como os ícones que são desenhados sobre as
transições para ajudar a entender seus tipos.
Gatilho de Descrição
transição
Timeout A transição ocorre depois de um intervalo de tempo especificado

contado a partir do momento em que o diagrama entra no estado
“fonte” da transição. A expressão de timeout pode ser estocástica
ou determinística.
Usos primários:
Atrasos: fica em um estado por um dado tempo, e depois sai.
Tempo limite: muda de estado se outros eventos aguardados
não ocorrerem no intervalo de tempo especificado.
Rate Usado para programar mudanças de estado esporádicas com um
tempo médio conhecido. Atua da mesma forma que a transição
acionada por timeout, mas o intervalo de tempo é determinado
por uma distribuição exponencial parametrizada com a taxa
dada. Por exemplo, se a taxa é de 0.2, os intervalos terão valores
médios de 1/0.2 = 5 unidades de tempo.
Condition A transição monitora uma condição booleana especificada e

reage quando ela se torna verdade. A condição é uma expressão
booleana arbitrária e pode depender dos estados de quaisquer
objetos do modelo com dinâmicas discretas ou contínuas.
Por favor, observe que a condição somente é verificada quando
algum evento ocorre no modelo. Para garantir que você não
esqueceu o momento de mudar de estado, recomendamos que
adicione um evento cíclico dentro do agente e que o faça acontecer
o suficiente para não perder o momento em que a condição da
transição se torna verdade.
Message Reage a mensagens de outros agentes. As mensagens podem
modelar comunicação entre pessoas, comandos dados a uma
máquina, etc. Você pode definir o template da mensagem nas
propriedades da transição, mas somente mensagens com este
template acionarão a transição.
Arrival Reage a chegada do agente ao destino.
Por favor, observe que a transição reage somente se o movimento
foi iniciado chamando a função moveTo() do agente.
Nossa transição é acionada com uma taxa especificada. No nosso caso, quando o
diagrama de estados entra no estado PotentialUser, uma projeção da distribuição
exponencial é realizada e o timeout é estabelecido. Cada tempo de adoção do
consumidor diferirá, embora uma média de 1% dos usuários potenciais comprará
o produto em determinado dia.
14. Agora, vamos configurar a unidade de tempo do modelo. Para ajustar a
configuração do modelo, mude de Palette para Projects, e depois clique no
item do modelo na árvore (o objeto do topo da árvore, Market). Na visão
Properties, escolha days como Model time units.
14
Tempo do modelo. Unidades de tempo de modelo

• O tempo do modelo é o tempo virtual (simulado) que o mecanismo de
simulação do AnyLogic tem. O tempo do modelo não está relacionado ao
tempo real ou ao clock do computador, embora você possa executar o modelo
na escala de tempo real.
• Para estabelecer o relacionamento entre o tempo do modelo e o tempo real

onde o sistema modelado existe, você precisará definir a unidade de tempo.
Você deve escolher a unidade de tempo que mais se adeque ao seu modelo,
próxima a duração das operações mais comuns do modelo.
Por exemplo, modelos de fluxos de pedestres normalmente usam segundos e
sistemas de serviços de fabricação normalmente usam minutos, mas alguns
modelos de economia global, social e ecológica definidos no estilo de
dinâmica de sistemas podem usar meses ou até mesmo anos.
15. Execute o modelo. A população deve se tornar verde gradualmente – uma
mudança que representa o efeito da propaganda – até que todos os
consumidores comprem o produto.
Quando o efeito da propaganda motiva o agente a comprar o produto, o estado do
agente User se torna ativo, a Entry action do estado é executada, e a cor da forma
de animação do agente muda para yellowGreen. À medida que mais pessoas
compram o produto, você verá as animações dos agentes do seu modelo ficando
verdes.
Modos de execução do modelo

Você pode executar um modelo AnyLogic em modo de tempo real ou tempo virtual.
• No modo de tempo real, você estabelece o relacionamento entre o tempo do

seu modelo e o tempo real selecionando quantas unidades de tempo do
modelo são iguais a um segundo do tempo real. Você normalmente usará o
tempo real quando quiser que a sua animação pareça realista.
• No modo de tempo virtual, o modelo é executado em sua velocidade máxima. O

modo de tempo virtual é útil quando você precisa simular o modelo por um
longo período, e o modelo não exigir definir um relacionamento entre as
unidades de tempo e os segundos do tempo astronômico.
No modo de tempo real, você pode aumentar ou diminuir a velocidade de execução
do seu modelo mudando a escala de velocidade de simulação. Por exemplo, x2
significa que o modelo executa duas vezes mais rápido que a velocidade
especificada para o modelo.
A barra de ferramentas Time scale permite que você ajuste a velocidade de
execução do modelo:
Desacelerar
Definir tempo real Alternar para
como escala padrão modo real/virtual
Acelerar
16. Para ajustar a velocidade de execução do modelo, clique nos botões Slow
down ou Speed up. Se você aumentar a velocidade para 10x – você verá que a
velocidade em que a população se torna verde aumenta.
Fase 3. Adicionando um gráfico para visualizar os

resultados do modelo
Nós queremos saber quantas pessoas compraram nosso produto em um
determinado momento. Com isso em mente, definiremos funções que
contabilizam os usuários e os usuários potenciais do nosso produto, depois
adicionaremos um gráfico para mostrar a dinâmica.
1. Primeiro, defina uma função que conte os usuários potenciais. Para adicionar
uma nova função que colete estatísticas do agente, abra o diagrama do agente
Main, selecione a população de agentes consumers, e vá para a seção Statistics
da aba propriedade.
2. Clique no botão Add statistics.
Precisamos determinar quantos agentes estão no estado PotentialUser.

3. Defina o tipo da função como Count com Name NPotential . As estatísticas do
tipo count percorrem uma população dada – no nosso caso, o número de
agentes – para contar aqueles que atendem a condição selecionada.
4. Digite item.inState(Consumer.PotentialUser) como Condition da função.
• item representa o agente sendo atualmente verificado na iteração.
• inState() é uma função que verifica se o estado especificado do diagrama

de estados está ativo.
• PotentialUser é o nome do estado definido do agente, por isso ele precisa

do prefixo de agente Consumer.
5. Defina uma segunda função estatística para calcular o número de usuários do

produto. Nomeie-a de NUser e faça-a contar o número de agentes que
atendem a Condition item.inState(Consumer.User). Você pode duplicar a
outra função estatística clicando no botão Duplicate e mudando seu

Name e Condition.
Agora, vamos adicionar um gráfico para mostrar as estatísticas que estas funções
coletam e exibir a dinâmica do processo de adoção.
6. Abra a paleta Analysis e arraste o Time Stack Chart da paleta Analysis para o
diagrama Main para criar um gráfico que exibirá as dinâmicas dos usuários e
dos usuários potenciais. Aumente o tamanho do gráfico como mostrado na
figura abaixo:
Gráficos
O AnyLogic fornece vários gráficos que você pode usar para visualizar os dados
que o seu modelo gera. Você pode encontrá-los na seção Charts da paleta Analysis.
Bar Chart
Exibe os itens de dados como

barras alinhadas em uma
extremidade. Os tamanhos das
barras são proporcionais aos
valores dos itens
correspondentes.
Stack Chart
Exibe os itens de dados

acumulados como barras
empilhadas. Os tamanhos das
barras são proporcionais aos
valores dos itens
correspondentes.
Pie Chart
Exibe os itens de dados

acumulados como setores de
um círculo. Os arcos de cada
setor são proporcionais aos
valores dos itens
correspondentes.
Plot
Desempenha um papel de
diagrama de fases. Cada data
set é formado de pares <x,y>.
O Plot exibe os valores-Y de
um data set em relação aos
valores-X. Os Valores-X são
mapeados para o eixo-X, os
valores-Y para o eixo-Y. Pode
exibir vários data sets ao
mesmo tempo.
Time Plot
Exibe o histórico recente de

vários itens de dados em uma
janela de tempo. Dependendo
do tipo de interpolação, a linha
entre as duas amostras é
interpolada linearmente ou
mantém o valor anterior até o
próximo.
Time Stack Chart
Exibe o histórico recente e

acumulado de uma quantidade
de itens de dados em uma
janela de tempo como áreas
empilhadas. Os valores são
empilhados continuamente no
topo do próximo com o
primeiro item adicionado
embaixo.
Time Color Chart

Mostra a tendência recente de
uma quantidade de data sets
como barras de listras
horizontais de cores diferentes
(a cor depende do valor do
dado). Se a condição avalia
para verdade, a cor da listra da
barra corresponderá a cor
definida para esta condição.
Use o gráfico para visualizar a
mudança de estados do agente
sobre o tempo, e.g.
ocupado/ocioso.
Histogram
Exibe as estatísticas coletadas
pelos objetos de Dados de
Histograma. Os histogramas
também são dimensionados
juntos ao eixo Y para que a
barra mais alta do histograma
ocupe a maior altura da figura.
Você pode optar também por
mostrar as barras em PDF,
CDF e média local.
Histogram2D
Exibe uma coleção de
histogramas 2D. Cada um é
desenhado com um conjunto
de pontos coloridos refletindo
o valor PDF ou a função
contínua correspondente em
(X,Y). Os eixos do gráfico
sempre são escalados para
caberem no histograma.
Adicione dois itens de dados ao gráfico para exibição. Aqui chamaremos as nossas
funções estatísticas de NUser e NPotential que definimos para a população
consumers no passo anterior.
7. Clique em Add data item para adicionar as estatísticas que você quer plotar
no gráfico.
8. Modifique as propriedades do item de dados:
• Title: Users – o título do item de dados.
• Color: yellowGreen
• Value: consumers.NUser()
O nome da nossa população de agentes é consumers e NUser() é a função

estatística que definimos para esta população.
9. Adicione mais um item de dados:
• Title: Potential users
• Color: lavender
• Value: consumers.NPotential()
Ajustando a escala de tempo do gráfico

• Gráficos com histórico (Time Plot, Time Stack Chart, Time Color Chart)
permitem ajustar a escala de tempo.
• Você configura o intervalo de tempo de um gráfico de tempo com a

propriedade Time window. Como esses gráficos exibem apenas uma
quantidade limitada de amostras em um determinado momento,
certifique-se de ter a quantidade adequada para a janela de tempo
selecionada.
• Se você executar o modelo e o seu gráfico se assemelhar a figura abaixo,

você deve aumentar a quantidade de amostras que o gráfico exibe ou
diminuir a time window do gráfico.
100 amostras, insuficiente para preencher o intervalo
Janela de tempo (time window): 1 ano (365 amostras esperadas)
Como queremos mostrar um intervalo de um ano, precisamos ajustar as

configurações do gráfico.
10. Vá para a seção Scale e defina a Time window para 1 year.
11. Como nosso gráfico mostrará estatísticas da população consumers e nosso

modelo tem 5,000 consumidores, defina a Vertical scale como Fixed e digite
5000 no campo To:.
12. Agora que configuramos a janela de tempo, altere a quantidade máxima de

amostras que o gráfico exibe na seção Data update e configure Display up to
365 latest samples. Como adicionaremos uma amostra por dia, 365 amostras
é a quantidade ideal para o intervalo de um ano.
13. Vá para a propriedade Appearance do gráfico e configure-a para exibir Model

date (date only) perto do eixo de tempo.
Formatando marcas temporais em rótulos de gráficos de tempo

Gráficos com histórico podem exibir modelos de data nos rótulos do eixo de
tempo (x), e você pode formatar as marcas temporais escolhendo um dos
formatos sugeridos ou usando o formato personalizado que melhor atender
as suas necessidades.
Personalize o formato da marca temporal na propriedade Time axis format
(localizada na seção Appearance das propriedades do gráfico). A seção abaixo
apresenta alguns exemplos de formatos de marca temporal:
Model date (date only)
Model date (time only)
Custom (HH:mm) – Somente horas e minutos são exibidos

14. No diagrama Main, mova a apresentação da população de agentes consumers

para a direita.
14
15. Execute o modelo e o use o gráfico time stack chart para analisar o processo.
Fase 4. Adicionando o efeito boca a boca

Nesta fase, modelaremos o que é conhecido como propaganda boca a boca – o
modo como as pessoas convencem umas às outras a comprar o nosso produto.
• Permita que as pessoas contatem umas às outras. No nosso modelo, um

consumidor contata em média uma pessoa por dia.
• Os usuários atuais do nosso produto podem influenciar usuários potenciais

durante esses contatos. Definiremos a probabilidade de um usuário potencial
comprar o produto como AdoptionFraction=0.01.
Vamos desenvolver a lógica do modelo adicionando dois parâmetros ao
consumidor: ContactRate e AdoptionFraction.
1. Na árvore de Projects, abra o diagrama Consumer dando um clique duplo em
Consumer.
2. Adicione um parâmetro para definir uma média de contatos diários do

consumidor. Arraste o Parameter da paleta Agent para o diagrama.
3. Nomeie o parâmetro como ContactRate.
4. A taxa é de 1 contato por dia, assim digite 1 como Default value do parâmetro.
5. Adicione outro parâmetro - AdoptionFraction – para definir a influência de
uma pessoa, um número que expressaremos como a porcentagem de pessoas
que usarão o produto depois que entrarem em contato com um consumidor.
Mantenha o Type padrão do parâmetro: double , e defina o Default value: 0.01.
O diagrama Consumer deve parecer como este:
Agora, deixaremos nossos agentes interagirem entre si. Isto representa o boca a
boca que convencerá uma porcentagem dos consumidores a comprar o produto.
Interações do agente
O AnyLogic suporta um mecanismo de comunicação único para a modelagem
baseada em agentes: envio de mensagens.
• Um agente pode enviar uma mensagem para outro agente ou um grupo de

agentes.
• Uma mensagem pode ser um objeto de qualquer tipo ou complexidade,

incluindo uma string de texto, um inteiro, uma referência para um objeto, ou
uma estrutura com muitas variáveis.
• Para enviar uma mensagem para outro agente, você usa uma função específica
do agente. As informações abaixo listam as funções mais frequentemente
usadas para enviar mensagens de um agente para outro(s):
sendToAll( msg ) – envia a mensagem para todos os agentes da mesma
população.
sendToRandom( msg ) – envia a mensagem para um agente escolhido
aleatoriamente da mesma população.
send( msg, agent ) – envia a mensagem para o agente dado (você passa a
referência do agente destinatário como segundo argumento da função)
No nosso modelo, somente usuários que estão no estado User enviarão

mensagens. A melhor maneira de definir uma atividade que um agente
desempenha em um estado – em outras palavras, uma atividade que eles realizam
sem saírem do estado atual – é usando uma transição interna.
6. Abra o diagrama Consumer, e aumente o estado User para caber a transição
interna que desenharemos no próximo passo.
7. Desenhe uma transição interna no estado User . Para desenhar uma transição
como essa abaixo, arraste uma Transition da paleta Statechart para dentro do
estado de modo que o ponto inicial fique sobre a borda do estado. Depois,
você pode mover o ponto final da transição pela borda do estado. Para
adicionar um ponto de curva, dê um clique duplo na transição.
 Transições externas e internas se comportam diferentemente, assim você

deve garantir que a sua transição fique completamente dentro do estado.
Transições internas
• Uma transição interna é uma transição cíclica que fica dentro de um estado. Os
pontos inicial e final ficam na borda do estado.
• Como uma transição interna não sai do estado que a contém, ela não leva o
diagrama de estados para outro estado. Nem as ações de entrada e saída são
executadas quando a transição ocorre, e o estado atual não é alterado.
8. Modifique as propriedades da transição. Esta transição acontecerá com a Rate
especificada ContactRate (use o autocomplemento de código ao invés de
digitar o nome completo do parâmetro). Nomeie a transição como Contact e

marque-a para mostrar seu nome.
9. Especifique a Action que será executada ao disparar esta transição (use o

autocomplemento de código para escrever o código):
sendToRandom("Buy");
Como queremos que os usuários do nosso produto falem com os usuários
potenciais, estabeleceremos uma transição cíclica no estado User. Toda vez que a
transição ocorrer, o código sendToRandom("Buy"); faz o consumidor escolher
aleatoriamente um agente e enviar a mensagem de texto “Buy” para ele. Se o
agente que recebe a mensagem é um usuário potencial (em outras palavras, se o
agente que recebe a mensagem está no estado PotentialUser), o estado do agente
mudará para User .
Vamos adicionar essa transição agora:
10. Desenhe outra transição do estado
PotentialUser para User e a nomeie de WOM.
Esta transição modelará compras resultantes
do boca a boca.
11. Modifique as propriedades da transição:
• Na lista Triggered by, clique em Message. 10
• Na área Fire transition, escolha On

particular message.
• No campo Message, digite "Buy"

• Como sabemos que nem todo contato é bem sucedido – em outras

palavras, um contato pode não convencer o usuário potencial a comprar
nosso produto – usaremos a AdoptionFraction para tornar contatos com
sucesso menos comuns. Especifique a Guard da transição:
randomTrue(AdoptionFraction)
Condições de guarda em transições

• Quando o diagrama de estados entra em um estado, os gatilhos de todas as
transições de saída são coletados e o diagrama de estados aguarda um deles
ocorrer.
• Quando um evento de gatilho ocorre, a condição de guarda da transição

correspondente é avaliada. Se a condição de guarda é verdade, a transição
pode ser feita (ainda que eventos simultâneos alternativos possam restaurar
o gatilho). Este algoritmo de avaliação de condição de guarda é chamado de
“guard-after-triggers”.
Este é o último passo na modelagem do marketing boca a boca. O AnyLogic
encaminha a mensagem do agente para o diagrama de estados, e, se o diagrama
de estados estiver no estado PotentialUser, ele provoca uma transição imediata
para o estado User . Se o diagrama de estados estiver em qualquer outro estado,

ele ignorará a mensagem.
12. Na visão Projects, você pode ver um asterisco do lado do item do modelo que
indica que o seu modelo tem alterações não salvas. Na barra de ferramentas,
clique em Save para salvar o seu modelo.
12
13. Execute o modelo.

A saturação do mercado deve ocorrer mais rapidamente e o gráfico mostra a
famosa curva S de adoção do produto.
Fase 5. Considerando os descartes do produto

Nesta fase, modelaremos os descartes do produto.
• Vamos assumir que a duração média de uso ativo do nosso produto é de

seis meses.
• Uma vez que o usuário descarta ou consome o produto, ele precisará de

uma reposição. Modelaremos o comportamento de comprar novamente
assumindo que os usuários se tornem usuários potenciais quando
descartarem ou consumirem suas primeiras unidades (em outras
palavras, quando User voltar para o estado PotentialUser).
1. Abra o diagrama Consumer e adicione o parâmetro DiscardTime.
2. Este parâmetro definirá a vida útil do nosso produto. Escolha Time como Type
do parâmetro, clique em months na lista Unit, e digite 6 como Default value.
3. Desenhe uma transição do estado User para o estado PotentialUser para
modelar os descartes do produto. Para desenhar uma transição com curvas
como aquelas mostradas na figura, dê um clique duplo no elemento
Transition da paleta Statechart (isto deve mudar o ícone do elemento na
paleta para ), clique no estado de origem da transição, User, clique nos
pontos de curva e clique no estado de destino, PotentialUser.
4. Nomeie a transição como Discard e configure-a para ser disparada por um

timeout constante DiscardTime. Na lista à direita, clique em months.
 O AnyLogic usa destaques vermelhos para chamar a atenção para transições

(como na figura abaixo à esquerda) onde o ponto final não está conectado ao
estado. Para localizar o erro, selecione a transição e os pontos conectados
serão destacados em azul turquesa (veja a figura à direita, conexão com
PotentialUser). Se o AnyLogic não destacar o ponto inicial da transição em
User, você deve manualmente mover este ponto para esse estado para
estabelecer a conexão e consertar o erro.
Consertando erros de digitação

Um nome de elemento do modelo digitado incorretamente é um erro comum. Os
nomes no AnyLogic diferenciam letras maiúsculas de minúsculas, o que significa
que digitar Discardtime (ao invés de DiscardTime) em uma propriedade do
elemento do modelo causará o seguinte erro:
Para consertar o erro, dê um clique duplo nele na visão Problems. Se o erro for
gráfico, o AnyLogic destacará o elemento que causou o erro no editor gráfico. Se o
erro é em uma propriedade do elemento, o AnyLogic abrirá as propriedades do
elemento e mostrará o campo onde o problema ocorreu.
Nosso trabalho para modelar os descartes do produto está completo, e qualquer
descarte gerará uma necessidade imediata de comprar um novo produto.
5. Execute o modelo e observe como os descartes afetam a dinâmica de adoção.
Mesmo depois que o nosso produto satura o mercado, você notará descartes
de produtos ocasionais.
Fase 6. Considerando o tempo de entrega

Nosso modelo assume que o produto está sempre disponível e a transição de
PotentialUser para User é incondicional e imediata. Agora, melhoraremos o
modelo adicionando um estado ao diagrama que reflete o período de tempo entre
a decisão de um agente para comprar o produto e o tempo que ele o recebe.
1. Prepare um lugar para outro estado entre PotentialUser e User movendo o
estado User para baixo.
2. Desconecte o estado User das transições.

Selecione as transições WOW e Ad , mova seus pontos finais para o topo da
tela, e desconecte a transição Discard de PotentialUser. Depois, você observará
que as transições desconectadas estão em vermelho.
3. Adicione outro State da paleta Statechart no meio do diagrama e o nomeie de

WantsToBuy. Os consumidores neste estado decidiram comprar o produto,
mas eles ainda não compraram.
3
4. Reconecte as transições ao estado do meio: as transições WOW, Ad e Discard

agora devem terminar no estado WantsToBuy.
5. Modifique WantsToBuy como nos outros estados:
Fill color: gold
Entry action: shapeBody.setFillColor(gold)
6. Adicione uma transição do estado WantsToBuy para o estado User, para

modelar o envio do produto, e a nomeie de Purchase.
7. Vamos assumir que geralmente um usuário leva dois dias para comprar o
produto. Isto significa que uma vez que o diagrama do consumidor entre no
estado WantsToBuy, ele procederá para o estado User em dois dias. Com isto
em mente, configure um timeout de dois dias para a transição Purchase:
8. Defina mais uma função estatística para contar a demanda baseada no

mercado do produto. No editor gráfico de Main, clique em consumers, vá para
a seção de propriedades Statistics, e adicione um item de estatística:
NWantToBuy com a condição item.inState(Consumer.WantsToBuy)
8
9. Em Main, selecione time stack chart, e adicione outro item de dado para ser
mostrado com o gráfico: consumers.NWantToBuy() com o título Want to buy e
cor gold.
10
10. Deixe o novo item de dado definido em segundo na lista selecionando a seção
do item e clicando no botão “up” .
11. Execute o modelo, e você observará que o AnyLogic exibe a quantidade de

consumidores que estão esperando pelo produto em amarelo.
Fase 7. Simulando a impaciência do consumidor

Nosso modelo precisa considerar os diferentes períodos de tempo que os
consumidores estão dispostos a esperar pela entrega do produto. Se o tempo de
entrega ultrapassa o tempo que um consumidor está disposto a esperar, o
consumidor reconsiderará sua decisão e voltará a ser um usuário potencial.
Vamos começar definindo dois parâmetros em Main: o tempo de entrega máximo
do produto (25 dias) e o tempo de espera máximo do consumidor (7 dias).
1. Abra o diagrama do tipo de agente Main.
2. Como não queremos que a janela do modelo mostre os seus parâmetros em
tempo de execução, podemos colocá-los para fora da área de visualização
padrão da janela.
Em Main, a janela do modelo é representada com um frame retangular. Os
elementos dentro do frame ficarão visíveis em tempo de execução, mas você
pode escondê-los movendo o canvas do diagrama um pouco para a direita e
colocando os dois parâmetros conforme mostrado na figura abaixo.
 Para mover o canvas do diagrama, mantenha o botão direito do mouse

pressionado enquanto você o movimenta.
3. Configure os parâmetros. MaxWaitingTime define o tempo máximo que um

consumidor esperará pelo produto (neste caso, sete dias).
4. Configure o parâmetro MaxDeliveryTime para 25 dias para refletir nossa

hipótese de que pode levar até 25 dias para entregar um produto.
Nós assumimos que leva de 1 a 25 dias – com uma média de dois dias – para
entregar o produto. Com isto em mente, vamos alterar o tempo de entrega de um
período de entrega fixo de dois dias para a expressão estocástica que descreve
esse padrão.
Funções de distribuição de probabilidade

A tabela abaixo descreve as distribuições frequentemente usadas no AnyLogic,
mas você encontrará a lista completa na seção Help do programa.
Distribuição de Uso principal

probabilidade
Uniform Você sabe os valores mínimo e máximo, mas
mean não sabe como os valores restantes estão
distribuídos entre eles. Em outras palavras,
você não sabe se alguns valores são mais
frequentes do que outros e assume que
qualquer ponto entre min e max tem a mesma
chance de receber um valor.
min max
uniform( min, max )
Triangular Você sabe o mínimo e o máximo, e tem um

mean palpite sobre o valor mais frequente (moda).
A distribuição triangular é frequentemente
usada para tempos de serviço ou duração de
operações onde você não tem amostras o
bastante para construir uma curva de
mod distribuição significativa.
min max
triangular( min, mode, max )
Exponential Descreve o tempo entre eventos em um

mean processo de Poisson, i.e. quando os eventos
ocorrem independentemente a uma taxa média
constante.
Usado como intervalo de tempo para fluxos de
entrada de clientes, peças, chamadas, pedidos,
transações ou falhas nos modelos de processo.
exponential( lambda, min ) Nos modelos baseados em agentes, uma
distribuição exponencial é usada como timeout
para transições de taxa que modelam eventos
independentes de agentes que são conhecidos
por ocorrerem em uma determinada taxa
média global.
Normal Fornece uma boa descrição de dados que

mean tendem a se agrupar em torno da média.
Observe que a distribuição normal é ilimitada
em ambos os lados, portanto, se você quiser
impor limites (e.g. evitar valores negativos)
você precisa usar a sua forma truncada ou usar
outras distribuições como a Lognormal,
mean
Weibull, Gamma ou Beta.
normal( sigma, mean )
Discrete uniforme Usada para modelar uma quantidade finita de

resultados igualmente prováveis, ou quando
você não sabe quais resultados são mais
prováveis de acontecer.
Observe que ambos os valores mínimo e
máximo são incluídos no conjunto de
resultados possíveis, assim uma chamada a
min max
função uniform_discr( 3, 7 ) pode retornar 3, 4,
5, 6 ou 7. (Borshchev, 2013)
uniform_discr( min, max )
Como você pode ver na tabela, a distribuição de probabilidade triangular é a

forma mais fácil de definir o padrão de tempo requisitado.
5. Abra o diagrama Consumer e selecione a transação Purchase. Nós queremos
mudar a expressão de timeout da transição, e faremos isso usando um
assistente para escolher a função de distribuição e inserir o nome da função
na propriedade. Para substituir o valor existente, use o mouse para selecionar
a expressão de Timeout atual.
6. Clique no botão Choose Probability Distribution….

7. Você verá a caixa de diálogo Choose Probability Distribution ….
8. A tela Choose Probability Distribution permite ver a lista de distribuições

suportadas, e você pode clicar em qualquer nome da lista para ver a descrição
da distribuição. Escolha a triangular na lista. Defina os parâmetros min, max e
mode iguais a 1, 25 e 2, respectivamente. No canto superior direito, você verá
a PDF construída instantaneamente para a distribuição com os parâmetros
especificados. Clique em OK quando terminar.
9. Você verá a expressão triangular(1, 25, 2) automaticamente inserida como
valor de timeout. Vamos mudar a linha para triangular(1,
main.MaxDeliveryTime, 2)
Aqui main é o modo como acessamos o agente Main a partir do agente consumer.
10. Desenhe a última transição CantWait que vai do estado WantsToBuy para o
estado PotentialUser. Esta transição modelará como a impaciência de um
consumidor o motiva a mudar sua decisão de compra, e o diagrama Consumer
parecerá como este:
10
11. Altere as propriedades da transição para que ela seja engatilhada pelo
Timeout que é igual a triangularAV(main.MaxWaitingTime, 0.15) days
Em vez de definir o tempo de espera máximo igual a constante MaxWaitingTime,

nós assumimos que ele segue uma distribuição triangular com uma média de uma
semana e uma possível variação de até 15%.
Nós podíamos facilmente definir o tempo de espera máximo e o tempo de entrega
máximo como parâmetros constantes, mas queremos variar estes números
dinamicamente e ver como estas alterações afetam o comportamento do sistema.
Uma forma de adicionar interatividade ao nosso modelo é adicionando controles
e vinculando-os aos parâmetros do modelo.
Controles
Os controles (controls) do AnyLogic podem ajudar a adicionar interatividade ao
seu modelo. Você pode usá-los para configurar parâmetros antes da execução do
modelo e alterar o modelo em execução. O controle pode executar códigos ou
fazer alterações nos parâmetros do modelo.
Você também pode associar uma ação arbitrária como uma chamada a uma
função, agendar um evento, enviar uma mensagem ou parar o modelo com um
controle. A ação é executada toda vez que o usuário tocar no controle. O valor do
controle é normalmente disponível como value no campo de código Action e
também é retornado pela função getValue() do controle.
A tabela abaixo descreve resumidamente cada controle.
Controle Descrição
Deixa o usuário influenciar o modelo

Button interativamente. Você pode definir uma ação
específica (na propriedade Action do botão) que o
modelo realizará todas as vezes que o usuário clicar
no botão em tempo de execução do modelo.
Controle que pode ser marcado ou desmarcado, e

Check Box que mostra seu estado para o usuário. Check boxes
são frequentemente usadas para mudar valores de
variáveis e parâmetros booleanos.
Um controle de texto que deixa o usuário digitar um

Edit Box pequeno texto. Você pode vincular este controle a
uma variável ou um parâmetro do tipo String,
double ou int. Neste caso, quando o usuário altera o
conteúdo do edit box, a variável/parâmetro
vinculado imediatamente recebe este conteúdo
como valor.
Radio Buttons Grupos de botões onde apenas um de cada vez pode

ser marcado. Você pode vincular este controle a
uma variável ou parâmetro do tipo int. Neste caso
quando o usuário escolhe outra opção do grupo, a
variável/parâmetro vinculado imediatamente
recebe o índice desta opção como valor. O primeiro
botão definido na tabela Radio Buttons tem índice
0, o segundo tem índice 1, e assim por diante.
Slider Deixa o usuário selecionar graficamente um valor

numérico dentro de um intervalo deslizando o
botão. Comumente usado para mudar valores de
variáveis e parâmetros numéricos em tempo de
execução do modelo. Se é difícil estabelecer valores
double precisos, você pode usar o edit box no lugar
dos sliders.
O AnyLogic Professional também suporta outros quatro controles:
• Combo Box
• List Box
• File Chooser
• Progress Bar
Adicionaremos um slider que nos deixará selecionar um valor numérico dentro de

um intervalo. Os sliders são muito usados para alterar valores de variáveis e
parâmetros numéricos.
12. Volte para o diagrama Main. Abra a paleta Controls e arraste dois Sliders para
o diagrama abaixo do gráfico. Vincularemos os sliders aos nossos dois
parâmetros.
13. Altere as propriedades do slider:
• Marque o checkbox Link to e selecione o parâmetro MaxWaitingTime à

direita.
• Defina Minimum value e Maximum value do slider. O valor do parâmetro

pode variar dentro do intervalo que você define aqui, e definiremos 2 como
Minimum value e 15 como Maximum value.
• Finalmente, clique no botão Add labels… para mostrar os valores atual,

máximo e mínimo do slider em tempo de execução (os nomes min, value e
max aparecerão abaixo do slider).
14. Adicione outro slider abaixo e configure-o como segue:
Alguns controles têm rótulos padrões, mas você deve usar a forma Text para criar
manualmente um texto para os sliders.
15. Abra a paleta Presentation, arraste duas formas Text para o diagrama, e as
posicione acima dos sliders. Vamos configurar os títulos desses controles.
16. Na visão de propriedades, na seção Text, digite o texto que o modelo

mostrará. Usando caixas de texto, nomeie um slider de Maximum waiting time
e o outro de Maximum delivery time.
16
17. Na seção de propriedades, abaixo de Appearance, você pode personalizar a

cor, o alinhamento, a fonte e o tamanho da fonte do texto.
Os rótulos que mostram os valores máximo, atual e mínimo são também formas
Text. Suas propriedades dinâmicas exibirão os valores máximo, mínimo e atual
em tempo de execução do modelo, e você pode editar seus rótulos como editaria
qualquer caixa de texto.
Você também pode mover o elemento consumers para a esquerda do frame da

janela de apresentação.
18. Execute o modelo e observe o comportamento. À medida que você usa os
sliders para mudar o tempo de espera ou de entrega máximos, você verá suas
alterações refletidas nos comportamentos dos consumidores e em toda a
dinâmica de adoção.
Fase 8. Comparando execuções do modelo com

valores de parâmetros diferentes
Nesta fase, queremos executar o modelo e observar o processo de adoção sob
diferentes configurações. Nós poderíamos alterar manualmente os valores dos
parâmetros, executar o modelo e salvar os resultados, mas é muito mais fácil usar
os experimentos nativos do AnyLogic para comparação de saídas.
Primeiro, construiremos um experimento que nos permita variar manualmente o
parâmetro ContactRate e comparar o comportamento do modelo. Nós queremos
que o nosso experimento investigue dados de um período que exceda um ano, e
usaremos 500 dias.
Experimento de Comparação de Execuções

Este experimento interativo permite digitar os parâmetros do modelo, executar
uma simulação, e adicionar as saídas da simulação aos gráficos para posterior
comparação.
A interface padrão do experimento inclui os campos de entrada e os gráficos de
saída. Os parâmetros definem a entrada, e o tipo de controle dos parâmetros
depende das configurações dos seus Value editor‘s.
1. Abra o diagrama Main e adicione um Data Set da paleta Analysis. Nomeie-o
usersDS.
O Data Set é capaz de armazenar dados 2D (X,Y) do tipo double. Nós

queremos que este dataset armazene o histórico da dinâmica de vendas do
produto. Vamos armazenar as amostras, cada uma com marca temporal e o
número atual de usuários do produto.
2. Para armazenar as marcas temporais, deixe a opção do dataset Use time as
horizontal axis value marcada.
3. Defina os valores que o dataset armazenará. Na propriedade Vertical axis

value, digite: consumers.NUser() .
4. O dataset mantém uma quantidade limitada dos itens de dados mais recentes,
e limitaremos o tamanho da nossa amostra a 500. Configure o dataset para
Keep up to 500 latest samples. Defina o Update data automatically com valor
padrão Recurrence time: 1 . Adicionaremos uma amostra para um dia do
tempo de vida do modelo.
Agora você tem o dataset que armazenará o histórico da variável principal (a

quantidade de usuários do produto). Ele obtém amostras chamando a função
estatística NUser() que criamos para a população de agentes consumers.
5. Em seguida, faça alterações na seção Value editor para ambos os parâmetros
do diagrama Main (MaxWaitingTime e MaxDeliveryTime). Escolha Slider como
Control type, defina os valores Min e Max iguais ao que temos nos sliders de
Main e, se preferir, mude o rótulo padrão (para Maximum waiting time).
Agora estamos prontos para criar um experimento de comparação de execuções.

6. Abra a visão Projects, clique com o botão direito no item do modelo, e
selecione New > Experiment no menu de contexto. O assistente New
experiment abrirá uma janela.
7. Selecione o experimento Compare Runs na lista de tipos de experimentos e

clique em Next.
8. Na página Parameters, adicione ambos os parâmetros à coluna Selection. Para

adicionar um parâmetro, selecione-o na lista Available à esquerda e clique na
seta . Você também pode clicar no botão para adicionar todos os

parâmetros. Clique em Next depois que ambos os parâmetros estiverem em
Selection.
9. Na próxima página do assistente, configure os gráficos de saída para este

experimento. O gráfico mostrará os dados coletados pelo dataset usersDS. Na
tabela Charts, faça tudo a seguir:
a. Na coluna Type, selecione dataset.
b. Na coluna Chart Title, digite Users.
c. Na coluna Expression, aponte para o dataset que você definiu em Main
como root.usersDS onde root é o agente principal do modelo (Main)
O diagrama do experimento CompareRuns deve abrir automaticamente, e você

verá a interface padrão que criamos com o assistente.
11. Nós queremos que o experimento simule o modelo para apenas 500 dias.
Para fazer isso, selecione o experimento CompareRuns na árvore de Projects.
Nas propriedades do experimento, abra a seção de propriedades Model time
e digite 500 no campo Stop time.
12. Execute o experimento. Selecione o experimento recém-criado na lista Run:

Market / CompareRuns, ou clique com o botão direito no experimento
CompareRuns na árvore de Projects e selecione Run no menu de contexto.
12
13. Na janela do modelo, clique no botão Run para ver o resultado associado com
os valores padrões dos parâmetros. Depois, altere os valores dos parâmetros
e clique em Run novamente para observar o comportamento do sistema para
novas configurações. O gráfico exibe todos os resultados para sua análise.
14. Cada curva do gráfico corresponde a uma execução de simulação específica, e

você pode clicar em qualquer item na legenda do gráfico para destacar as
curvas correspondentes a execução. Os controles à esquerda exibirão os
valores que levaram ao resultado. Para desmarcar uma curva, clique na sua
legenda novamente.
15. Você pode copiar os datasets clicando na legenda e selecionando Copy all ou
Copy selected no menu de contexto.
Agora que você acabou de desenvolver o modelo baseado em agentes Market, você
pode estendê-lo tornando a lógica do consumidor mais sofisticada (por exemplo,
introduzindo produtos concorrentes). Você pode encontrar o modelo Statechart
for Choice of Competing Products na seção Models de “Big Book of Simulation
Modeling” dos modelos de exemplo do AnyLogic. Para visualizar os modelos,
escolha Examples no menu Help.
Modelagem de Dinâmica de Sistemas

“Dinâmica de sistemas é uma perspectiva e um conjunto de
ferramentas conceituais que nos permite entender a estrutura e a
dinâmica de sistemas complexos. Dinâmica de sistemas também é um
método de modelagem rigoroso que nos permite construir simulações
computacionais formais de sistemas complexos e usá-las para definir
políticas e organizações mais eficazes.”
John Sterman, “Business Dynamics:

Systems Thinking and Modeling for a Complex World”
O método de dinâmica de sistemas foi criado na década de 50 pelo professor do

MIT Jay Forrester. Com base em sua experiência em ciência e engenharia,
Forrester procurou usar as leis da física, em particular as leis dos circuitos
elétricos, para investigar os sistemas econômicos e sociais.
Hoje, dinâmica de sistemas é normalmente usada em modelos de longo prazo,
modelos estratégicos, e ela pressupõe altos níveis de agregação de objetos:
Modelos DS representam pessoas, produtos, eventos e outros itens discretos, por
suas quantidades.
A dinâmica de sistemas é uma metodologia para estudar sistemas dinâmicos. Ela
sugere:
• Modelar o sistema como uma estrutura causal fechada que define o seu
próprio comportamento.
• Descobrir equilíbrio ou reforço de ciclos de retroalimentação

(causalidade circular) do sistema. Ciclos de retroalimentação são o
coração da dinâmica de sistemas.
• Identificar estoques (acumulações) e fluxos que os afetam.

Estoques são acumulações e descrevem o estado do sistema. Elas são a memória
do sistema e as fontes de desequilíbrio. O modelo funciona somente com grupos –
os itens do estoque são indistinguíveis. Os fluxos são as taxas nas quais os estados
destes sistemas mudam.
Se você está tendo dificuldade em distinguir entre estoques e fluxos, considere
como os medimos. Estoques são geralmente expressos em quantidades tais como
pessoas, níveis de estoque, dinheiro ou conhecimento, enquanto fluxos são

normalmente medidas de quantidades em um período de tempo dado, como
clientes por mês ou dólares por ano.
Este capítulo ensinará como usar o AnyLogic para desenvolver modelos de
dinâmica de sistemas. Se você quiser mais informações sobre a abordagem de
dinâmica de sistemas, recomendamos o livro Business Dynamics: Systems Thinking
and Modeling for a Complex World de John Sterman.
O modelo SEIR
Estamos prestes a construir um modelo que mostre a disseminação de uma
doença contagiosa em uma grande população. Nosso modelo terá uma população
de 10,000 pessoas – um valor que chamamos de TotalPopulation – das quais uma
está infectada.
• Durante a fase infecciosa, uma pessoa entra em contato com uma média
de ContactRateInfectious = 1.25 pessoas por dia. Se uma pessoa infectada
entra em contato com uma pessoa suscetível, a probabilidade de infecção
da pessoa suscetível é de Infectivity = 0.6.
• Depois que uma pessoa suscetível é infectada, a fase latente de infecção

dura AverageIncubationTime = 10 dias. Usaremos a palavra exposed para
descrever as pessoas que estão na fase latente.
• Depois da fase latente, a fase infecciosa começa. Esta fase dura

AverageIllnessDuration = 15 dias.
• As pessoas que se recuperaram da doença estão imunes a uma segunda

infecção.
Fase 1. Criando um diagrama de estoque e fluxo

1. Crie um novo modelo, selecionando File > New > Model, com o nome SEIR.
Vamos começar desenhando o diagrama de estoque e fluxo. Para modelar o
avanço de uma epidemia, precisamos reduzir a diversidade populacional. Neste
exemplo, consideraremos quatro características importantes:
• Susceptible – as pessoas que não estão infectadas pelo vírus
• Exposed – as pessoas que estão infectadas, mas que não infectam
• Infectious - as pessoas que estão infectadas e que infectam
• Recovered – as pessoas que se recuperaram do vírus
SEIR é um acrônimo que representa quatro estágios: Suscetível-Exposto-

Infeccioso-Recuperado. A terminologia e a estrutura geral do problema foram
tiradas de ("Compartmental models in epidemiology". s.d.) -- especificamente, do
modelo SEIR (Susceptible Exposed Infectious Recovered).
Há quatro estoques no nosso modelo- um para cada estágio.
2. Abra a paleta System Dynamics. Arraste o Stock da paleta para o diagrama.

Nomeie-o Susceptible.
3. Adicione mais três estoques. Posicione-os como mostrado na figura e os

nomeie de Exposed, Infectious e Recovered.
Estoques e fluxos
Em Dinâmica de Sistemas, estoques (também conhecidos como níveis,
acumulações ou variáveis de estado) representam estoques reais de materiais,
conhecimento, pessoas, dinheiro, etc. Fluxos definem suas taxas de mudança –
como os valores dos estoques mudam e definem a dinâmica do sistema. Aqui
estão alguns exemplos de estoques e fluxos:
Estoque Fluxo de Entrada Fluxo de Saída
População Nascimentos Mortes

Imigração Emigração
Tanque de Reabastecimento Consumo de

combustível combustível
O fluxo pode sair de um estoque e entrar em outro. Tal fluxo é de saída para o
primeiro estoque e de entrada para o segundo, ao mesmo tempo:
O fluxo pode entrar em um estoque a partir do nada. Neste caso a nuvem

(representando uma "fonte") é desenhada no ponto inicial do fluxo.
E, simetricamente, o fluxo pode sair de um estoque para "lugar nenhum". Neste

caso a nuvem (representando um "sorvedouro") é desenhada no ponto final do
fluxo.
A seta do fluxo mostra sua direção.

No nosso modelo, as pessoas suscetíveis são expostas ao vírus, se tornam
infectadas e se recuperam em seguida. É uma progressão que requer do nosso
modelo usar três fluxos para levar as pessoas de um estoque para o próximo.
4. Adicione o primeiro fluxo que sai do estoque Susceptible para Exposed. Dê um
clique duplo no estoque de onde o fluxo sai (Susceptible ), e depois clique no
estoque onde o fluxo entra (Exposed).
5. Nomeie o fluxo como ExposedRate.
6. Você pode ver as fórmulas dos estoques Susceptible e Exposed. Como o fluxo
ExposedRate reduz o valor do estoque Susceptible e aumenta Exposed, as
fórmulas devem ser as mesmas, como na figura acima. O AnyLogic
automaticamente criou essas fórmulas quando você adicionou o fluxo.
Fórmulas de estoques
O AnyLogic gera automaticamente a fórmula de um estoque de acordo com o
diagrama de estoque e fluxo do usuário.
O valor do estoque é calculado de acordo com os fluxos de entrada e saída do
estoque. O valor das entradas – os fluxos que aumentam o valor do estoque – é
adicionado e o valor das saídas – fluxos que reduzem o estoque – é subtraído do
valor atual do estoque:
fluxoEntrada1 + fluxoEntrada2 … - fluxoSaída1 - fluxoSaída2 …
No sistema clássico, apenas a notação dos fluxos aparece na fórmula. A fórmula
não é editável e nenhum outro tipo de elemento, a não ser os fluxos de entrada e
saída, podem aparecer na fórmula.
7. Adicione um fluxo de Exposed para Infectious e o nomeie como
InfectiousRate.
8. Adicione um fluxo de Infectious para Recovered e o nomeie como

RecoveredRate.
9. Reorganize os nomes dos fluxos como mostrado na figura abaixo. Para fazer
isso, selecione um fluxo e arraste seu nome.
9
10. Agora, vamos definir os parâmetros e as dependências. Adicione cinco

Parameters, os renomeie, e defina seus valores padrões de acordo com as
informações abaixo:
• TotalPopulation = 10 000
• Infectivity = 0.6
• ContactRateInfectious = 1.25
• AverageIncubationTime = 10
• AverageIllnessDuration = 15
10
11. Defina o número de pessoas infectadas especificando 1 como Initial Value do

estoque Infectious.
12. Defina o Initial Value para o estoque Susceptible: TotalPopulation-1.
Você pode pressionar Ctrl+espaço (Mac OS: Alt+espaço) e depois selecionar o
nome do parâmetro do assistente de autocomplemento de código.)
12
Você verá um sinal vermelho à esquerda da expressão. A razão para este

problema é que você definiu uma dependência entre dois elementos no diagrama
de estoque e fluxo (o valor inicial do estoque Susceptible depende do parâmetro
TotalPopulation), mas esta dependência não está definida graficamente como
deveria ser.
Conexões de Dependência
Os diagramas de estoque e fluxo têm dois tipos de dependências:
• Um elemento (estoque, fluxo, auxiliar ou parâmetro) é mencionado em

uma fórmula de um fluxo ou auxiliar. Este tipo de conexão é desenhado
com uma linha contínua:
• Um elemento é mencionado no valor inicial do estoque. Este tipo de

conexão é desenhado com uma linha tracejada:
Você deve usar conexões para definir graficamente as dependências entre os

elementos de um diagrama de estoque e fluxo.
Se um elemento A é mencionado na equação ou valor inicial do elemento B ,
primeiro você deve conectar estes elementos com uma conexão de A para B e
depois digitar a expressão nas propriedades de B .
13. Desenhe uma conexão de dependência de TotalPopulation para Susceptible:
Na paleta System Dynamics, dê um clique duplo no elemento Link, clique em
TotalPopulation, e depois clique no estoque Susceptible . Você deve ver a
conexão com círculos pequenos desenhados em suas extremidades:
13
14. Vamos definir a fórmula para o fluxo ExposedRate.

Clique no fluxo e defina a seguinte fórmula usando o assistente de
autocomplemento de código:
Infectious*ContactRateInfectious*Infectivity*Susсeptible/TotalPopulation
14
Precisamos desenhar as conexões de dependência das variáveis e parâmetros

mencionados neste fluxo. Você pode achar um tédio desenhar manualmente essas
conexões, assim mostraremos como adicioná-las usando o mecanismo de
autocriação de conexões do AnyLogic.
15. Clique com o botão direito no fluxo ExposedRate no diagrama gráfico, e
escolha Fix Variable Links > Create Missing Links no menu de contexto.
Depois, você deve visualizar as conexões no diagrama de estoque e fluxo:
16. Defina a seguinte fórmula para InfectiousRate:

Exposed/AverageIncubationTime
17. Defina a seguinte fórmula para RecoveredRate:

Infectious/AverageIllnessDuration
18. Desenhe as conexões de dependência restantes, e o seu diagrama de estoque
e fluxo deve parecer com a imagem a seguir:
19. Ajuste a aparência das conexões de dependência. Modifique os ângulos de

curvatura das conexões para deixar o diagrama parecido com a figura abaixo.
Para ajustar os ângulos de curvatura, selecione-os, e depois arraste a alça no
meio da conexão.
20. Execute o modelo e examine a dinâmica usando as janelas de inspeção de

variáveis. Para abrir a janela de inspeção de uma variável, clique na variável
para selecioná-la. Para redimensionar a janela, arraste seu canto direito
inferior.
20
21
21. Para mudar a janela de inspeção para o modo gráfico, clique no ícone mais à
esquerda em sua barra de ferramentas.
22. Aumente a velocidade de execução do modelo para fazer a simulação ir mais
rápido.
Fase 2. Adicionando um gráfico para visualizar a

dinâmica
Ciclos de retroalimentação: equilíbrio e reforço
A dinâmica de sistemas estuda dependências causais nos sistemas. Há dois tipos
de ciclos de retroalimentação: reforço e equilíbrio.
Aqui estão algumas dicas sobre como saber o tipo de ciclo (tirado da Wikipédia).
Para determinar se um ciclo causal é de reforço ou equilíbrio, comece com uma
suposição como a "VariableN aumenta," e depois siga o ciclo.
O ciclo é de:
• reforço se, depois de dar uma volta no ciclo, você obtém o mesmo
resultado da suposição inicial.
• equilíbrio se o resultado contradiz a suposição inicial.

Você também pode usar uma definição alternativa:
• ciclos de reforço têm um número par de conexões negativas (zero

também é par)
• ciclos de equilíbrio têm um número ímpar de conexões negativas.

Adicionaremos um identificador de ciclo.
1. Arraste o elemento Loop da paleta System Dynamics para o diagrama, e
depois posicione-o como mostrado na figura.
1
2. Vá para as Properties do ciclo, mude seu Type para R (de Reforço), mantenha
Clockwise Direction, e especifique o texto que o AnyLogic exibirá perto do
ícone do ciclo: Contagion.
Identificadores de Ciclos
Ciclo (Loop) é um identificador gráfico com um rótulo que descreve
resumidamente o significado do ciclo e uma seta que mostra o seu sentido.
No lugar de definir o ciclo causal, ele fornece informações sobre como as variáveis
do diagrama de estoque e fluxo afetam umas às outras. Ao adicionar um ciclo,
você pode ajudar outros usuários a entenderem as influências e as dependências
causais do diagrama de estoque e fluxo.
O ciclo Contagion é de reforço. Um aumento em Infectious leva a um aumento
da ExposedRate que, por sua vez, leva a um aumento maior de Exposed. Todos as
conexões deste ciclo são positivas.
Descubra quais são os outros ciclos neste diagrama de estoque e fluxo. Quais são
seus sentidos e tipos?
Vamos adicionar um Time Plot para plotar as pessoas em Susceptible, Exposed,
Infectious e Recovered.
3. Arraste o Time Plot da paleta Analysis para o diagrama e o redimensione,

como mostrado na figura abaixo.
4. Na visão Properties, vá para a seção Data e clique no botão para

adicionar um novo item de dados.
5. Modifique as propriedades do item de dados:
• Title: Susceptible people – título do item de dados.
• Valor: Susceptible (use o autocomplemento de código).
6. Adicione três itens de dados para exibir os valores dos estoques Exposed,
Infectious e Recovered do mesmo jeito – e não esqueça de definir os Títulos
correspondentes.
7. Concluímos nosso modelo. Agora, execute o modelo e use o gráfico que você
adicionou para ver sua dinâmica.
Fase 3. Experimento de variação de parâmetros

Nesta fase, usaremos o experimento de variação de parâmetros do AnyLogic para
determinar como diferentes taxas de contato afetam a taxa de infecção.
Experimento de variação de parâmetros

O experimento de variação de parâmetros nos permite criar uma simulação de
modelo complexa que desempenha uma série de execuções do modelo que variam
por um ou muitos parâmetros. Depois que o experimento é concluído, o AnyLogic
pode mostrar os resultados de cada execução em um diagrama simples para nos
ajudar a melhor entender como os parâmetros variáveis afetaram os resultados
do nosso modelo.
Se executarmos nosso modelo com valores de parâmetros fixos, podemos avaliar
o efeito de fatores aleatórios em modelos estocásticos.
1. Para adicionar um experimento ao modelo, clique com o botão direito no item
de modelo (SEIR) na árvore de Projects, vá em New, e depois clique em
Experiment.
2. No campo Name do assistente New Experiment, digite ContactRateVariation. O

AnyLogic selecionará automaticamente o tipo de agente Main como Top-level
agent.
3. Na área Experiment Type, clique em Parameter Variation, e clique em Finish.

Depois de criar o experimento, suas propriedades e o diagrama abrirão.

4. Nas propriedades do experimento, abra a seção Parameters. Os parâmetros do
agente principal do experimento (no nosso caso, Main) são mostrados.
Por padrão, todos os parâmetros são definidos como fixed. Estes valores não
mudarão durante o experimento de variação de parâmetros.
5. Para assegurar que nosso experimento varie a taxa de contato, localize o

parâmetro ContactRateInfectious na tabela e mude o Type para Range.
6. Estabeleça os valores máximo e mínimo do parâmetro definindo Min: 0.3 e
Max: 2 com um Step de 0.1.
7. Na área Propriedades, clique em Create default UI.
O diagrama do experimento mostrará a interface de usuário básica.

8. Para garantir que cada execução simule exatamente 300 dias, precisamos
limitar o tempo de vida do modelo para 300 dias. Clique em
ContactRateVariation na árvore de Projects para abrir suas propriedades. Na
visão Properties, abra a seção Model time, selecione Stop at specified time na
lista Stop, e digite 300 no campo Stop time.
Agora, adicionaremos um Time Plot para mostrar os resultados do nosso
experimento. Nosso primeiro passo é coletar os dados sobre a quantidade de
pessoas infectadas.
9. Abra o diagrama Main, clique com o botão direito no estoque Infectious e
depois clique em Create Data Set.
10. Depois que o data set InfectiousDS aparecer, vá até suas propriedades. Como
queremos ver a dinâmica da doença infecciosa, deixe o checkbox Use time as
horizontal axis value marcado.
11. Escolha Update data automatically e deixe Recurrence time: 1 para adicionar
uma amostra ao nosso dataset para cada dia de vida do modelo.
12. Para obter as amostras de toda a execução do modelo, configure o dataset
para Keep up to 300 latest samples.
Estamos prontos para adicionar um gráfico ao diagrama do experimento
ContactRateVariation que exibirá nossos resultados.
13. Abra o diagrama ContactRateVariation, e arraste um Time Plot da paleta

Analysis.
14. Abra as propriedades do Time Plot. Na seção Scale, certifique-se que o Time
Plot mostre dados para 300 unidades de tempo do modelo configurando a
Time window para 300 model time units.
15. Aumente a área da legenda do gráfico arrastando a alça em formato de

losango em direção ao topo da tela.
15
Cada curva do gráfico mostrará os resultados de uma execução do modelo: o

histórico de disseminação da doença para uma taxa de contato coletada pelo
dataset InfectiousDS.
16. Clique em ContactRateVariation na árvore de Projects para abrir suas
propriedades, e depois adicione dados ao gráfico indo até a seção Java actions
e digitando o seguinte código no campo After simulation run:
plot.addDataSet( root.InfectiousDS,
"CR=" + format( root.ContactRateInfectious ) );
16
Embora queiramos que o nosso gráfico mostre múltiplas curvas – uma para cada
execução da simulação – não podemos adicionar os dados de cada execução
diretamente nas propriedades de Data do gráfico. Cada execução do modelo
destrói o agente principal e seus dados, e como nosso modelo não consegue
armazenar os dados acumulados, precisamos adicionar manualmente cada curva

ao gráfico.
Ao final de cada simulação, o AnyLogic armazena os dados no dataset
InfectiousDS do agente Main. O agente principal do experimento é acessível como
root, o que significa que acessamos o data set como root.InfectiousDS.
Nós poderíamos usar addDataset(root.InfectiousDS) para adicionar um dataset ao

gráfico com a aparência padrão e título "Data set". Contudo, queremos que o
AnyLogic adicione uma série de legendas que nos ajudará a identificar as curvas
dos gráficos, e é por isso que usaremos uma outra notação da função addDataSet()
que tem dois argumentos, addDataSet(DataSet ds, String title).
Construímos uma legenda para o dataset com o texto CR= (onde CR significa
Contact Rate) e o valor ContactRateInfectious. Como o agente principal do modelo
(root) define este parâmetro, acessaremos seu valor como
root.ContactRateInfectious e usaremos a função format(double value) para
controlar como o AnyLogic converte os valores para texto. Por exemplo,
queremos que a legenda do nosso gráfico mostre valores, como 0.30001,
arredondados.
17. Abra a seção Advanced das propriedades do experimento
ContactRateVariation e depois desmarque o checkbox Allow parallel
evaluations.
18. Estamos prontos para executar o experimento e usar nosso gráfico para
observar os dados coletados de múltiplas execuções da simulação. Na barra
de ferramentas, na lista Run, selecione SEIR / ContactRateVariation.
19. Na janela de apresentação, clique em Run.

19
O AnyLogic realiza uma série de execuções que usa diferentes valores para o
parâmetro ContactRateInfectious e depois adiciona a saída da simulação ao
gráfico.
Se você analisar os resultados do experimento de variação de parâmetros, verá
como as taxas de contato elevadas permitem que a infecção avance mais
rapidamente. Verá também que o gráfico exibe 18 iterações – em outras palavras,
18 cenários de infecção para taxas de contato que variam de 0.3 a 2 – que
representam os 18 passos do intervalo de variação de parâmetros que definimos
anteriormente. Você pode destacar uma curva clicando em seu valor de Taxa de
Contato (CR) na legenda.
Fase 4. Experimento de calibração

Nesta fase, ajustaremos os parâmetros do nosso modelo para assegurar que seu
comportamento corresponda a um padrão conhecido (observado).
Como não podemos medir diretamente os dois parâmetros – Infectivity e
ContactRateInfectious – precisamos determinar seus valores antes que usemos o
modelo. O melhor modo de fazer isso é usando calibração, um processo que utiliza
dados históricos de um caso similar e valores de parâmetros ajustados para
ajudar a garantir que nosso modelo reproduza os dados históricos.
Experimento de calibração
• O experimento de calibração usa o otimizador nativo OptQuest para
localizar os valores de parâmetros do modelo que correspondam a saída
da simulação que melhor se ajusta aos dados fornecidos.
• O experimento de calibração executa o modelo iterativamente, compara

as saídas do modelo ao padrão histórico, e então muda os valores dos
parâmetros. Depois de uma série de execuções, o experimento
determinará quais valores de parâmetros produzem os resultados que
melhor correspondem ao padrão histórico.
Começaremos adicionando os dados históricos – a quantidade de pessoas
infectadas no tempo – ao nosso modelo. Enquanto as amostras são armazenadas
em um arquivo de texto no formato de tabela, a função tabela do AnyLogic nos
permite usar esses dados para construir a curva.
Funções tabela
• Função tabela (table function) é uma função definida no forma de tabela.
O usuário define uma função fornecendo alguns pares (argumento,
valor), e depois o AnyLogic usa uma combinação dos dados e o tipo de
interpolação selecionado para construir a função tabela. Uma chamada a
função que passa um valor como argumento retornará (possivelmente,
interpolado) um valor da função.
• Você pode precisar de funções tabela para definir um relacionamento

não linear complexo que não pode ser descrito como uma composição de
funções padrões, ou para trazer dados experimentais definidos como
uma função tabela para um modo contínuo.
1. Abra o diagrama Main e adicione uma Table function da paleta System

Dynamics. Nomeie-a InfectiousHistory.
2. Abra o arquivo HistoricData.txt em Diretório do AnyLogic /resources/AnyLogic

em 3 dias/SEIR . O Diretório do AnyLogic é o local onde o AnyLogic foi
instalado no seu computador, como Arquivos de Programas /AnyLogic 7
Professional.
3. Copie o conteúdo do arquivo de texto para o Clipboard, vá para a seção Table

Data das propriedades da função tabela, e depois clique no botão Paste from
clipboard . As colunas Argument e Value se atualizarão automaticamente.
3
4. Você pode visualizar a curva feita pela função tabela na seção Preview das
propriedades da função tabela.
5. Defina a opção Out of range como Nearest para assegurar que a função
considere casos onde o argumento da função exceda o valor de 300 que
definimos em Table data.
Estamos usando a opção Nearest para garantir que o argumento válido mais
próximo extrapole a função. Isto quer dizer que em todos os argumentos à
esquerda do intervalo, a função tomará o valor do ponto mais à esquerda. Do
mesmo modo, todos os argumentos à direita do intervalo, a função tomará o valor
no ponto mais à direita. A visualização do gráfico reflete as interpolações e
extrapolações atuais.
Estamos prontos para criar o experimento.
6. Clique com o botão direito do mouse no item de modelo (SEIR) na árvore de
Projects, vá para New, e depois clique em Experiment. No assistente New
Experiment, escolha Calibration como Experiment type e depois clique em
Next. Neste momento, usaremos o assistente para configurar os parâmetros.
7. Mude os tipos de parâmetros que queremos calibrar (Infectivity e

ContactRateInfectious) de fixed para continuous, e depois defina os valores
Min e Max do intervalo como mostrado na figura abaixo.
8. Na tabela Criteria mostrada abaixo, digite as seguintes informações.
• Title: Infectious curve match
• Match: data series
• Simulation output: root.InfectiousDS
• Observed data: root.InfectiousHistory
• Coefficient: 1.0
Novamente, o agente principal Main está disponível aqui como root. Nós usamos o
dataset InfectiousDS para manter a saída do modelo no fim da execução da
simulação e compará-la com os dados históricos da função tabela
InfectiousHistory.
Embora nosso modelo tenha um critério, você pode usar coeficientes se o seu
modelo tiver vários critérios.
9. Clique em Finish. O diagrama do experimento Calibration mostrará a interface
de usuário configurada (UI).
A figura abaixo mostra as propriedades do experimento. Seu objetivo é minimizar

a diferença entre a saída do modelo e os dados históricos.
10. Abra a seção Advanced das propriedades do experimento de calibração e

depois desmarque o checkbox Allow parallel evaluations.
11. Execute o experimento de calibração clicando com o botão direito em
Calibration na visão Projects e depois em Run, ou selecionando SEIR /
Calibration na lista de experimentos no menu Run da barra de ferramentas.
12. Depois que a calibração for concluída, você pode copiar os valores otimizados
dos parâmetros clicando no botão copy da janela de experimento e depois
colá-los dentro do experimento de simulação clicando no botão Paste from
clipboard que você encontrará na página propriedades do experimento
Simulation.
Depois que você tiver colado os valores do parâmetro no experimento, você pode
executar Simulation com os valores de parâmetros recém-criados.
Modelagem de eventos discretos

A modelagem de eventos discretos tem quase a mesma idade da modelagem de
dinâmica de sistemas. Em 1961, o engenheiro da IBM Geoffrey Gordon apresentou
o GPSS, considerado o primeiro software a implementar o método de modelagem
de eventos discretos. Hoje, vários programas – incluindo versões modernas do
GPSS – oferecem a modelagem de eventos discretos.
 A modelagem de eventos discretos exige pensar sobre o sistema que se quer

modelar como um processo – uma sequência de operações que os agentes
realizam.
As operações de um modelo podem incluir atrasos, serviços de vários recursos,

seleções de ramos de processos, separações e muitos outros. Desde que agentes
disputem recursos limitados e possam se atrasar, filas farão parte de quase todos
os modelos de eventos discretos.
O modelo é especificado graficamente como um fluxograma de processo onde
blocos representam as operações. O fluxograma geralmente inicia com blocos
"fonte" que geram agentes e os insere no processo e termina com blocos
"sorvedouros" que os remove.
Agentes – originalmente chamados de transações no GPSS ou entidades em outros
softwares de simulação – podem representar clientes, pacientes, chamadas de
telefone, documentos físicos e eletrônicos, peças, produtos, paletes, transações
computacionais, veículos, tarefas, projetos, ideias, e assim por diante. Recursos
representam funcionários, doutores, operadores, operários, servidores, CPUs,
memórias de computador, equipamentos e transportes.
Tempos de serviço e tempos de chegada de agentes são geralmente estocásticos, e
uma vez que eles são resultado de uma distribuição de probabilidade, os modelos
de eventos discretos são estocásticos. Em termos simples, isto significa que um
modelo deve executar por um tempo específico ou completar um número
específico de replicações antes de produzir uma saída significativa.
Saídas típicas esperadas de um modelo de eventos discretos incluem:
• Utilização de recursos
• Tempo gasto no sistema, ou em parte, por um agente

• Tempos de espera
• Filas
• Desempenho do sistema
• Gargalos
Modelo de Fábrica
Nosso objetivo é criar um modelo de evento discreto que simulará os processos
de fabricação e transporte de uma pequena fábrica. As matérias-primas que são
entregues na plataforma de recebimento são armazenadas até que o
processamento se inicie na máquina CNC .
Fase 1. Criando um modelo simples

Iniciaremos criando um modelo simples que simulará a chegada dos paletes na
fábrica, seu armazenamento na plataforma de embarque e sua chegada no setor
de empilhadeiras.
1. Crie um novo modelo. No assistente New Model, defina Model name: Job Shop,
e Model time units: minutes.
2. Abra a paleta Presentation. Ela tem algumas formas que você pode usar para
desenhar a animação do modelo, incluindo rectangle, line, oval, polyline e
curve.
3. Na paleta Presentation, selecione a forma Image e arraste-a para o diagrama
Main. Você pode usar a forma Image para adicionar imagens em alguns
formatos gráficos -- incluindo PNG, JPEG, GIF e BMP – a sua apresentação.
3
4. Você verá a caixa de diálogo aguardando a escolha do arquivo de imagem que

a forma exibirá.
5. Navegue para o local a seguir e selecione a imagem layout.png:
Diretório do AnyLogic/resources/AnyLogic in 3 days/Job Shop
Depois que selecionar a imagem layout.png, o diagrama do tipo de agente Main
deve parecer com a seguinte imagem:
O AnyLogic adiciona ao diagrama Main a imagem no seu tamanho original, mas

você também pode mudar o comprimento e a largura da imagem. Se você
distorcer as proporções da imagem como na figura abaixo, você pode reverter
para o tamanho original da imagem abrindo a visão Properties e clicando em
Reset to original size.
6. Selecione a imagem no editor gráfico. Na visão Properties, marque o checkbox

Lock para bloquear a imagem.
Bloqueando formas
• Você pode bloquear uma forma para garantir que ela não responda ao clique
do mouse e você não consiga selecioná-la no editor gráfico. Você descobrirá
que isto é muito útil enquanto desenha formas em cima de layouts que
representam instalações como fábricas ou hospitais.
• Se precisar desbloquear uma forma, clique com o botão direito sobre o editor
gráfico e selecione Unlock All Shapes no menu de contexto.
Elementos de marcação de espaço

O nosso próximo passo é usar a paleta Space Markup para colocar formas de
marcação de espaço sobre o layout da fábrica. A paleta inclui um elemento Path,
três elementos Node, um elemento Attractor e formas Pallet Rack.
Criando uma rede

Caminhos (Paths) e nós (nodes) são elementos de marcação de espaço que
definem as localizações dos agentes:
• Um Node é um lugar onde os agentes podem ficar ou realizar uma operação.
• Um Path é uma rota que os agentes podem usar para se mover entre os nós.
Juntos, nós e caminhos formam uma rede que os agentes de um modelo podem
usar para se mover ao longo dos menores caminhos entre os nós de origem e
destino. Você geralmente criará uma rede quando os processos do modelo
ocorrerem em um espaço físico definido e tiverem agentes e recursos se
movendo. Supõe-se que os seguimentos da rede têm capacidade ilimitada, e os
agentes não interferem uns aos outros.
Agora que você sabe um pouco sobre redes e suas componentes, estamos prontos
para criar uma rede que definirá os caminhos para os paletes do modelo. O
primeiro passo é usar nós retangulares para definir áreas específicas sobre o
layout da fábrica.
Desenhe um nó retangular na entrada da fábrica, como mostrado na figura abaixo,
para representar a plataforma de recebimento de paletes do modelo.
7. Abra a paleta Space Markup, e arraste o elemento Rectangular Node para o
diagrama Main. Redimensione o nó. O nó deve parecer com o da figura abaixo.
8. Nomeie o nó criado de receivingDock.
9. Desenhe um nó para definir o local onde os agentes do modelo estacionarão as

empilhadeiras quando estiverem ociosas, ou quando os agentes não
precisarem mais delas para completar uma tarefa. Use outro Rectangular
node para desenhar a área de estacionamento, como mostrada na figura
abaixo, e depois nomeie este nó como forkliftParking.
Vamos desenhar um caminho para guiar as empilhadeiras do nosso modelo.

10. Para desenhar o caminho que guiará as empilhadeiras do modelo, faça o
seguinte:
a. Na paleta Space Markup, dê um clique duplo no elemento Path para
ativar o modo desenho.
b. Desenhe o caminho como mostrado na figura abaixo clicando na
borda do receivingDock, clicando no diagrama para adicionar o ponto
de curvatura do caminho, e depois clicando na borda do nó
forkliftParking.
Se você conectou os nós com sucesso, os pontos de conexão do caminho

mostrarão destaques em azul turquesa todas as vezes que você selecionar o
caminho.
10
Por padrão, os caminhos no AnyLogic 7 são bidirecionais. Contudo, você pode

restringir o movimento ao longo de um caminho selecionado para uma direção
desmarcando a propriedade Bidirectional e depois definindo o sentido da direção.
Você pode ver o sentido de um dado caminho selecionando o caminho e depois
visualizando a seta de sentido que aparece no editor gráfico.
11. Defina a área de armazenamento do seu modelo arrastando o elemento Pallet
Rack da paleta Space Markup para o layout e posicionando seu corredor no
caminho. Um pallet rack bem colocado exibirá um destaque verde que
mostra que ele está conectado à rede.
11
Prateleiras de paletes
O elemento de marcação de espaço Pallet Rack representa as prateleiras de
paletes que você normalmente vê em armazéns ou áreas de armazenamento.
Como você pode ver abaixo, o elemento tem três configurações alternativas.
Durante o tempo de execução, o elemento Pallet Rack gerencia os agentes que o

modelo armazena nas células de um nível ou múltiplos níveis que estão
disponíveis nas laterais(s) do corredor.
12. Na área Properties da prateleira de paletes, faça o seguinte:
a. Configure Type para: two racks, one aisle
b. Number of cells: 10
c. Level height: 10
Na seção Position and size:
d. Length: 160
e. Left pallet rack depth: 14
f. Right pallet rack depth: 14
g. Aisle width: 11
13. Depois que você tiver completado essas alterações, a prateleira de paletes
deve parecer com a prateleira mostrada na figura abaixo. Se necessário, mova
a prateleira para que o centro do corredor fique sobre o caminho. Verifique se
a prateleira está conectada à rede clicando duas vezes para selecioná-la. Seu
primeiro clique selecionará a rede inteira, e o segundo a prateleira. A
prateleira deve exibir um destaque verde que mostra que ela está conectada à
rede.
13
Nós marcamos o espaço do nosso modelo desenhando locais e caminhos

importantes sobre o nosso layout, e agora usaremos a Biblioteca de Modelagem de
Processos do AnyLogic para modelar os processos.
Biblioteca de Modelagem de Processos

Os blocos da Biblioteca de Modelagem de Processos (Process Modeling Library) do
AnyLogic permitem usar combinações de agentes, recursos e processos para criar
modelos centrados em processos de sistemas do mundo real. Você aprendeu
sobre agentes e recursos anteriormente nesta seção, e construiremos sobre esses
fundamentos definindo os processos como sequências de operações que incluem
filas, atrasos e utilização de recursos.
Os processos do seu modelo são definidos por fluxogramas, representações
gráficas de processos que você constrói com os blocos da Biblioteca de
Modelagem de Processos. Nos passos a seguir, você criará o fluxograma do
processo.
14
14. Arraste o elemento Source da paleta Process Modeling Library para o

diagrama gráfico e nomeie o bloco de sourcePallets.
Como o bloco Source geralmente atua como um ponto de partida de

processos, o modelo vai usá-lo para gerar os paletes.
15. Na área Properties do bloco sourcePallets, faça o seguinte para garantir que os
paletes do modelo cheguem a cada cinco minutos e apareçam no nó
receivingDock.
a. Na área Arrivals defined by, clique em Interarrival time.

b. No campo Interarrival time, digite 5 , e selecione minutes na lista à
direita para que os paletes cheguem a cada cinco minutos.
c. Na área Location of arrival, clique em Network / GIS node na lista.
d. Na área Node, clique em receivingDock na lista.
Como referenciar os elementos do modelo com os

parâmetros do bloco
Os parâmetros do bloco oferecem dois meios de selecionar um elemento gráfico:
• Você pode selecionar um elemento gráfico na lista de elementos válidos e
disponíveis que aparece ao lado do parâmetro.
• Você pode selecionar um elemento gráfico clicando no botão de seleção

que fica ao lado da lista. Se você clicar no botão de seleção, ele restringirá
suas escolhas aos elementos válidos e disponíveis que você pode selecionar
clicando no editor gráfico:
Continue construindo o fluxograma adicionando outros blocos da Process

Modeling Library:
16. Arraste o bloco RackStore da paleta Process Modeling Library para o

diagrama e o posicione perto do bloco sourcePallets para que eles se
conectem automaticamente como mostrado no diagrama abaixo.
O bloco RackStore coloca paletes em determinadas células da prateleira.
16
17. Na área Properties do bloco rackStore, faça o seguinte:

a. No campo Name, digite storeRawMaterial.
b. Na lista Pallet rack / Rack system, clique em palletRack.
c. Na lista Agent location (queue), clique em receivingDock para especificar
o local onde os agentes aguardam para serem armazenados.
18. Adicione um bloco Delay para simular como os paletes ficam na prateleira e
depois nomeie o bloco de rawMaterialInStorage.
18
Você deve ter notado que o AnyLogic automaticamente conecta a porta da direita
do bloco à porta da esquerda do bloco seguinte. Cada bloco da Biblioteca de
Modelagem de Processos tem uma porta de entrada à esquerda e uma porta de
saída à direita, mas você somente deve conectar portas de saída à portas de
entrada.
19. Na área Properties do bloco rawMaterialInStorage, faça o seguinte:
a. No campo Delay time, digite triangular(15, 20, 30) e selecione
minutes na lista.
b. Marque o checkbox Maximum capacity para garantir que os agentes

não ficarão presos enquanto esperam para serem coletados da área
de armazenamento.
20. Adicione um bloco RackPick, conecte-o ao fluxograma e depois o nomeie de

pickRawMaterial.
No nosso modelo, o bloco RackPick retira um palete de uma célula prateleira

e o move para o destino especificado.
20
21. Na área Properties do bloco pickRawMaterial, faça o seguinte:

a. Na lista Pallet rack / Rack system, clique em palletRack para
selecionar a prateleira que fornecerá os paletes aos agentes.
b. Na lista Node, clique em forkliftParking para especificar onde os
agentes devem estacionar as empilhadeiras.
22. Adicione um bloco Sink. O bloco Sink descarta os agentes e geralmente é um

ponto final do fluxograma.
22
23. Nós terminamos de construir este modelo simples, e agora você pode
executar e observar seu comportamento. Execute o modelo (experimento Job
Shop / Simulation).
Se a mensagem de erro Exception during discrete event execution aparecer, você

deve conectar sua prateleira à rede. Você deve selecionar a forma pallet rack no
editor gráfico, movê-la até que o corredor da prateleira exiba um destaque verde
que mostre que ela está conectada à rede, e depois execute o modelo novamente.
Fase 2. Adicionando recursos

Vamos continuar desenvolvendo nosso modelo adicionando recursos –
empilhadeiras – para armazenar os paletes na prateleira e depois levá-los para a
área de produção.
Recursos
Recursos são objetos que os agentes utilizam para realizar uma determinada ação.
Um agente deve obter o recurso, realizar a ação, e depois liberar o recurso.
Alguns exemplos de recursos incluem:
• Doutores, enfermeiros, equipamentos, e cadeiras de roda de um modelo

de hospital
• Os veículos e contêineres de um modelo de cadeia de suprimentos
• Empilhadeiras e funcionários de um modelo de armazém

Existem três tipos de recursos: static, moving e portable.
• Recursos static estão ligados a um local específico, e não podem se mover ou

serem movidos.
• Recursos moving podem se mover independentemente.
• Recursos portable podem ser movidos por agentes ou por recursos móveis.
No AnyLogic, o bloco ResourcePool da Biblioteca de Modelagem de Processos
define cada conjunto de recursos. As unidades de recursos podem ter atributos
individuais, e cada recurso tem um diagrama gráfico onde você pode adicionar
elementos como diagramas de estados, parâmetros e funções.
Os recursos do nosso modelo são as empilhadeiras que movem os paletes da área
de descarga para uma prateleira e depois leva os paletes da prateleira para a área
de produção.
1. Na paleta Process Modeling Library, arraste o bloco ResourcePool para o

diagrama Main. Você não precisa conectar o bloco ao fluxograma.
2. Nomeie o bloco de forklifts.
3. Na área Properties do bloco forklifts, clique no botão create a custom type.

Deste modo criamos um novo tipo de recurso.
4. No assistente New agent:
a. No campo Agent type name, digite ForkliftTruck.
b. Na lista, na parte esquerda do assistente, expanda a área Warehouses
and Container Terminals, e depois clique na figura de animação 3D
Fork Lift Truck.
c. Clique em Finish.
O diagrama de tipo de agente ForkliftTruck abrirá e mostrará a forma de
animação que você selecionou no assistente.
5. Clique na aba Main para abrir o diagrama Main.
Você verá que o tipo de recurso ForkliftTruck foi selecionado no parâmetro

New resource unit do bloco ResourcePool.
6. Modifique os outros parâmetros do tipo de recurso forklifts:

a. No campo Capacity, digite 5 para estabelecer a quantidade de

empilhadeiras no nosso modelo.
b. No campo Speed, digite 1 e selecione meters per second na lista à
direita.
c. Na área Home location (nodes), selecione o nó forkliftParking. Clique
no botão mais e depois clique em forkliftParking na lista de nós

do modelo.
Definimos nossos recursos, mas ainda precisamos ter certeza de que os blocos do
fluxograma do nosso modelo os usarão durante os processos simulados.
7. Na área Properties do bloco storeRawMaterial, faça o seguinte:
a. Clique na seta para expandir a área Resources.
b. Marque o checkbox Use resources to move.
c. Na lista Resource sets (alternatives), clique em forklifts para garantir que
o bloco do fluxograma use os recursos selecionados – no nosso caso, as
empilhadeiras – para mover os agentes.
d. Na área Return home, escolha if no other tasks para garantir que as
empilhadeiras retornem para o local inicial depois que completarem suas
tarefas.
8. Na área Properties do bloco pickRawMaterial, faça o seguinte:

a. Clique na seta para expandir a área Resources .
b. Marque o checkbox Use resources to move.
c. Na lista Resource sets (alternatives), clique em forklifts para garantir

que o bloco do fluxograma use as empilhadeiras para mover os agentes.
d. Na área Return home, clique em if no other tasks para garantir que as
empilhadeiras retornem ao local inicial depois que completarem suas
tarefas.
Se os recursos do nosso modelo movem um agente, o bloco RackStore (ou
RackPick) pega ele, traz para o local do agente, anexa o agente, move o agente
para a célula, e depois libera os recursos.
Você verá que as empilhadeiras pegam os paletes e os armazena na prateleira.

Depois de um pequeno atraso, elas movem os paletes para a área de
estacionamento de empilhadeiras onde os paletes desaparecerão.
Fase 3. Criando animações 3D

Você viu muitas das funcionalidades que ajudam o AnyLogic a ser uma ferramenta
de modelagem poderosa. Mas, existem outras que você ainda não usou, e uma das
mais interessantes é a animação 3D.
Apresentando Objetos Câmera

Os objetos câmera do AnyLogic permitem definir a perspectiva que aparece na
janela 3D. Em essência, o objeto câmera "tira" as imagens que você vê.
Você também pode criar vários objetos câmera para mostrar diferentes áreas da
mesma cena 3D ou para mostrar um objeto de diferentes pontos de vista. Se você
usa mais de um objeto câmera, você pode mudar facilmente de uma perspectiva
para outra em tempo de execução.
1. Na paleta Presentation, arraste o objeto Camera para o diagrama Main para
que ele fique de frente para o layout da fábrica.
2. Arraste o objeto 3D Window para o diagrama Main, e depois o posicione
abaixo do fluxograma do processo.
1
Janelas 3D
Além de ter a opção de adicionar várias câmeras ao seu modelo, você também
pode adicionar várias janelas 3D para que cada uma mostre a mesma cena 3D de
diferentes pontos de visualização.
3. Deixe a câmera “tirar” a foto para a janela 3D. Na área Properties da janela 3D,
clique em camera na lista Camera.
4. Impeça a câmera de tirar a foto de debaixo do chão selecionando a opção
Limited to Z above 0, na lista Navigation type.
Quando você cria uma janela 3D, o AnyLogic adiciona uma área de
visualização para que você navegue facilmente para a visão 3D em tempo de
execução. Para mudar para a visão 3D, clique no botão Navigate to view
area… da barra de ferramentas e depois clique em [window3d].
A área de visualização expande a janela 3D para o tamanho da janela do

modelo.
5
6. Faça uma ou mais vezes as ações a seguir para navegar em 3D em tempo de

execução:
• Para mover a câmera para a esquerda, direita, para frente ou para trás,
arraste o mouse na direção selecionada.
• Para mover a câmera para perto ou longe do centro da cena, use o
scroll no mouse.
• Para girar a cena em relação à câmera, arraste o mouse enquanto

mantém pressionado o ALT e o botão esquerdo do mouse.
7. Escolha a visão que você quer mostrar em tempo de execução, clique com o
botão direito (Mac OS: CTRL+clique) dentro da cena 3D, e depois clique em
Copy the camera’s location.
8. Feche a janela do modelo.

9. Na área Properties da câmera, aplique a posição da câmera que você
selecionou durante o passo anterior clicando em Paste coordinates from
clipboard.
NOTA: Se você não conseguir localizar a sua câmera, você pode usar a árvore de
Projects. Ela mostrará a camera no ramo Presentation do agente Main.
10. Execute o modelo para visualizar a visão 3D da posição da nova câmera, e

depois feche a janela do modelo.
11. Expanda a área Pedestrian da paleta Space Markup e dê um clique duplo no
ícone do elemento Wall para habilitar o modo desenho do AnyLogic.
11
12. Faça o seguinte para desenhar paredes ao redor da área de trabalho do layout
da fábrica:
a. Clique na posição do editor gráfico onde você quer começar a
desenhar a parede.
b. Mova o ponteiro em qualquer direção para desenhar uma linha reta,
e depois clique em qualquer ponto onde você quiser mudar de
direção.
c. Dê um clique duplo no ponto onde você quer parar de desenhar a

parede.
12
13. Faça o seguinte para mudar a textura e a cor de preenchimento da parede:

a. Na área Properties da parede, expanda a seção Appearance.
b. No menu de cores, clique em Other colors.
c. Na janela de diálogo Colors, selecione a cor da paleta ou do espectro
que você quer aplicar na parede.
Você também pode definir um nível de transparência (use o slider
Transparency da caixa de diálogo Colors) ou personalize a parede
com qualquer textura fornecida (clique no item Textures… no menu
de cores).
Nesta seção, estamos usando as paredes para decorar nosso modelo. Mais
adiante no tutorial, onde modelaremos as ações de pedestres em um
aeroporto, veremos como as paredes também podem ser obstáculos.
14. Vá para a seção Position and size da parede e mude Z-Height para 40.
O AnyLogic automaticamente define a altura da forma para 20 pixels para
garantir que ela tenha volume em uma visão 3D, mas aumentamos agora sua
altura para 40 pixels.
15. Desenhe outra parede entre as saídas e depois mude as configurações na área
Properties da segunda parede para ficar igual à primeira.
15
16. Execute o modelo e veja a animação 3D.

Você verá que a animação do nosso modelo exibe formas cilíndricas para
representar os paletes, corrigiremos esse problema criando um tipo de
agente que defina uma animação personalizada para paletes.
17. Na área Properties do bloco sourcePallets, sob a lista New agent, clique no link
create a custom type.
17
18. No assistente New agent, faça o seguinte:

a. No campo The name of new type, digite Pallet.
b. Na lista, à esquerda do assistente, expanda a área Warehouses and

Container Terminals, e depois clique na figura de animação 3D Pallet.
18
O AnyLogic cria o tipo de agente Pallet e abre o diagrama Pallet que mostrará a
animação que selecionamos no assistente. Nosso próximo passo será adicionar a
animação de produtos em cima da animação do palete, mas primeiro
ampliaremos a visualização para nos aproximarmos do palete.
19. Usando a barra de ferramentas Zoom, amplie o diagrama Pallet para 500%, e
depois mova o canvas para a direita e para baixo para visualizar o ponto de
origem dos eixos e a forma de animação palete.
Ampliando ou reduzindo a visão

A barra de ferramentas Zoom do AnyLogic permite ampliar ou reduzir a visão do
diagrama gráfico:
Zoom para 100% Ampliar
Reduzir
20. Faça o seguinte para começar adicionando a animação de produto em cima da

animação do palete.
a. Na paleta 3D Objects, expanda a área Boxes.
b. Arraste o objeto Box 1 Closed para o canto superior esquerdo do
palete.
20
19
21. Como esta caixa parece ser muito grande se comparada ao palete, vamos
mudar a Scale da caixa para 75%.
21
22. Na área Properties da caixa, expanda a seção Position, e depois altere a

coordenada Z da caixa para 2.
Nossa alteração reflete o fato de que queremos colocar caixas sobre os paletes
e a altura de cada palete é de 2 píxeis.
23. Adicione três caixas copiando a primeira três vezes. Para copiar a caixa,
selecione-a e depois mantenha pressionado o CTRL enquanto arrasta a caixa.
Nosso palete agora tem quatro caixas fechadas, e agora você pode mudar o
nível do zoom de volta para 100% clicando no botão Zoom to 100% da
barra de ferramentas.
Ctrl + drag
23
24. Retorne ao diagrama Main.

Se você abrir a área Properties do bloco sourcePallets , verá que Pallet está
selecionado como New agent. Este bloco gerará agentes do tipo Pallet .
Você verá que as formas dos paletes tiveram os cilindros coloridos
substituídos. Contudo, se você ampliar a cena 3D, você observará que as
empilhadeiras não estão transportando os paletes. Corrigiremos este
problema ao movermos a animação de palete do nosso modelo de uma
maneira que permita a empilhadeira pegar os paletes.
25
26. Na visão Projects, dê um clique duplo no tipo de agente ForkliftTruck para

abrir seu diagrama e mova a figura forkliftWithWorker uma célula para a
direita.
A forma de animação está agora no local correto e os paletes do nosso modelo
estão alinhados com o garfo da empilhadeira.
26
27. Abra o diagrama Main, na área Properties da prateleira, no campo Number of

levels, digite 2 .
DICA: Lembre-se que o primeiro clique seleciona a rede e o segundo clique

seleciona o elemento da rede.
28. Na área Properties do bloco do fluxograma storeRawMaterial, defina o
parâmetro Elevation time per level para 30 seconds.
29. Na área Properties do bloco pickRawMaterial, defina o parâmetro Drop time
per level para 30 seconds.
30. Execute o modelo e verá uma prateleira de dois níveis.

Fase 4. Modelando a entrega de paletes por

caminhões
Nesta parte do tutorial, adicionaremos os caminhões que levam os paletes para a
fábrica. Vamos começar criando um tipo agente para representá-los.
1. Na paleta Process Modeling Library, arraste o elemento Agent type para o
diagrama Main.
2. Na tela Agent animation do assistente New agent, faça o seguinte:
a. No campo The name of new type, digite Truck.
b. Na lista abaixo, expanda a área Road Transport e clique em Truck.
Vamos adicionar mais dois elementos a nossa rede: um nó onde os caminhões

aparecerão e o caminho que eles seguirão até a área de recebimento.
3. Abra o diagrama Main ,
4. Sob a paleta Space Markup, clique no elemento Point Node e o arraste para a
entrada de caminhões.
5. Nomeie o nó de exitNode.
6. Desenhe um Path para conectar exitNode ao receivingDock .
Verifique se todos os elementos de marcação de espaço se conectam à rede.
7. Crie outro fluxograma de processo para definir a lógica de circulação de

caminhões conectando os blocos da Process Modeling Library na ordem a
seguir:
Source – MoveTo – Delay – MoveTo – Sink.
• O bloco Source gera um caminhão.
• O primeiro bloco MoveTo direciona o caminhão até a entrada da fábrica.

Os blocos de fluxograma MoveTo movem agentes para novos lugares na
rede. Se recursos são anexados ao agente, eles se movimentarão com eles.
• O bloco Delay simula a descarga de paletes.
• O segundo bloco MoveTo direciona o caminhão para a saída.
• O bloco Sink remove o caminhão do modelo.

8. Nomeie o bloco Source como sourceDeliveryTrucks.
9. Na área Properties do bloco sourceDeliveryTrucks, faça o seguinte para ter um
novo agente do tipo Truck chegando na entrada a cada hora a uma velocidade
específica:
a. Na lista Arrivals defined by, clique em Interarrival time.
b. No campo Interarrival time, digite 1 , e selecione hours na lista à
direita.
c. Na lista New agent, clique em Truck.
d. Na lista Location of arrival, clique em Network/GIS node.
e. Na lista Node, clique em exitNode.
f. No campo Speed, digite 40 , e selecione kilometers per hour na lista à
direita.
10. Nomeie o primeiro bloco MoveTo como drivingToDock.

11. Na área Properties do bloco drivingToDock, na lista Node, clique em
receivingDock para definir o destino do agente.
12. Renomeie o bloco Delay para unloading.

13. Na área Properties do bloco unloading, faça o seguinte:
a. Na área Type, clique em Until stopDelay() is called.
b. Na lista Agent location, clique em receivingDock.
A duração da operação depende da rapidez que os paletes são descarregados e

removidos pelas empilhadeiras. Consideraremos esta operação completa quando
o bloco RackStore termina de armazenar os paletes, e modelaremos isso mudando
o modo de operação do bloco Delay.
Controlando programaticamente o tempo de atraso

Você normalmente especificará um Delay time para a operação do bloco Delay. Ele
pode ser uma duração constante, como cinco minutos, ou uma expressão
estocástica que produz um tempo de atraso, como triangular(1, 2, 6).
Você pode também controlar programaticamente a duração da operação e parar o
atraso quando necessário, chamando a função correspondente do bloco. Se você
precisar parar a espera para todos os agentes que estão em Delay, chame a função
do bloco stopDelayForAll(). A outra função – stopDelay(agent) – para a operação
e libera o agente especificado.
14. Nomeie o segundo bloco MoveTo como drivingToExit.

15. Em drivingToExit. Na área Properties do bloco, na lista Node, clique em
exitNode para definir o destino do nó.
15
Os dois blocos Source do nosso modelo geram dois tipos de agentes: os caminhões
que aparecem a cada hora e os paletes que são gerados a cada cinco minutos.
Como queremos que os paletes apareçam quando o caminhão descarregar,
mudaremos o modo de chegada para o bloco Source que os gera.
Controlando a geração de agentes

Você pode ter o bloco Source gerando agentes em intervalos definidos,
configurando o parâmetro Arrivals defined by do bloco para Calls of inject()
function. Você será capaz de controlar a criação de agentes em tempo de execução
chamando a função inject(int n) do bloco.
Esta função gera a quantidade de agentes determinada no momento que a
chamada ocorre. Você define o número de agentes que o bloco gerará usando um
argumento de função como em sourcePalltets.inject(12);.
16. Na área Properties do bloco sourcePallets, na lista Arrivals defined by, clique
em Calls of inject() function.
16
17. Faça o seguinte para que o bloco sourcePallets gere paletes quando um
caminhão entra no bloco unloading:
a. Na área Properties do bloco unloading, expanda a seção Actions.
b. No campo On enter, digite o seguinte:
sourcePallets.inject(16);
Esta função Java garantirá que o nosso modelo gere 16 paletes todas as
vezes que um caminhão começar a descarregar.
17
Agora que adicionamos caminhões ao nosso modelo, vamos fazer com que a
primeira entrega apareça na inicialização do modelo para que não tenhamos que
esperar uma hora do tempo do modelo passar.
18. Na área Properties do agente Main, expanda a seção Agent actions e depois
digite a seguinte função Java no campo On startup:
sourceDeliveryTrucks.inject(1);
18
O código de inicialização do modelo

O código de inicialização (Startup code) do modelo é executado no estágio final de
sua inicialização, depois que os blocos são construídos, conectados e inicializados.
Este é um campo para inicializações adicionais e atividades iniciais de agentes,
como eventos.
19. Na área Properties do bloco storeRawMaterial, expanda a seção Actions e, no
campo On exit, digite o seguinte:
if( self.queueSize() == 0 )
unloading.stopDelayForAll();
Neste exemplo, self é um atalho que usamos para nos referir ao bloco
storeRawMaterial.
Se não houverem paletes na fila de armazenamento, o tempo de atraso do bloco

unloading para (em outras palavras, stopDelayForAll() é chamado), e o caminhão
deixa o bloco unloading e entra no próximo bloco do fluxograma, drivingToExit.

21. Se o caminhão estiver alinhado incorretamente como na figura abaixo, faça o
seguinte para consertar isso.
a. Na árvore de Projects, dê um clique duplo no agente Truck para abrir

seu diagrama e ver a figura de animação de caminhão.
b. No editor gráfico, selecione a forma de caminhão e use a alça circular,
ou a propriedade Rotation Z,°, na área de propriedades Position para
girar o caminhão em -180 graus.
21
Nós alteramos a posição da figura do caminhão, mas também precisaremos

mudar a configuração padrão do AnyLogic para ter certeza de que o
programa não a gire uma segunda vez.
22. Faça o seguinte para mudar a configuração padrão do AnyLogic:
a. Na área Projects, clique em Truck.
b. Na área Properties do tipo de agente Truck, clique na seta para
expandir a área Movement.
c. Desmarque o checkbox Rotate animation towards movement.
22
23. Abra o diagrama Main .

24. Para garantir que os paletes estejam corretamente posicionados no nó da
rede receivingDock, abra a paleta Space Markup e arraste um Attractor para
receivingDock. Deixe-o de frente para a entrada.
24
Attractors em nós
Os attractors permitem controlar a localização do agente dentro de um nó.
• Se o nó define o destino para onde os agentes se movem, os attractors definem

os pontos exatos dentro do nó.
• Se o nó define um local de espera, os attractors definem os pontos exatos onde

os agentes aguardarão dentro do nó.
Attractors também definem a orientação da animação do agente enquanto o

agente espera dentro do nó. Aqui usamos o attractor para este propósito
particular.
Você pode adicionar attractors arrastando-os individualmente para o diagrama
Main, mas se os attractors formam uma estrutura regular, você deve usar o
assistente especial para adicionar vários attractors ao mesmo tempo. O assistente
oferece alguns modos diferentes de criação, bem como a opção para remover
todos os attractors, e você pode exibi-la clicando no botão Attractors na área
Properties do nó.
25. Execute o modelo para observar o comportamento do caminhão.

A animação deve funcionar como esperado.
Fase 5. Modelando máquinas CNC

Nesta parte do nosso tutorial, simularemos máquinas CNC que processam
matérias primas. Começaremos marcando o espaço e usando point nodes para
definir os locais das máquinas CNC.
1. Abra a paleta Space Markup, arraste o elemento Point node sobre o layout da
fábrica e nomeie-o nodeCNC1.
2. Copie este nó para marcar o espaço da segunda máquina CNC.
O AnyLogic nomeará o segundo nó como nodeCNC2.
Precisaremos criar caminhos para conectar estes dois nós a nossa rede. As
empilhadeiras do nosso modelo precisarão deles para chegarem às máquinas
CNC.
3. Na paleta Space Markup, clique no elemento Path e desenhe os caminhos como
mostrado na figura abaixo. Para conectar um caminho a um point node, clique
no centro do point node.
NOTA: Certifique-se de que os caminhos desenhados conectam o nodeCNC1 e
nodeCNC2 à rede. Você pode testar a conexão de um caminho clicando duas
vezes para selecioná-lo. Se o caminho estiver conectado à rede, destaques em
azul turquesa aparecerão ao redor de seus pontos finais.
Uma máquina CNC é uma unidade de recurso. Vamos adicioná-la ao modelo

criando um tipo de recurso e usando o bloco ResourcePool para definir o conjunto
de recursos.
4. Na paleta Process Modeling Library, clique e arraste o bloco ResourcePool para
o diagrama Main.
5. Na área Properties do bloco ResourcePool, faça o seguinte:
a. No campo Name, digite cnc.
b. Na lista Resource type, clique em Static para refletir o fato de que este
é um recurso estático.
Com nosso conjunto de recursos completo, estamos prontos para criar um novo
tipo de recurso.
6. Sob a lista New resource unit, clique no link create a custom type.
a. No campo Agent type name, digite CNC.
b. Na lista abaixo, expanda a última seção (CNC Machines) e selecione
CNC Vertical Machining Center 2 State 1.
8. Feche o diagrama do novo tipo CNC e volte para o diagrama Main.
9. Na área Properties do bloco ResourcePool cnc, faça o seguinte para colocar as
duas máquinas CNC do nosso modelo nos lugares definidos pelos point nodes,
nodeCNC1 e nodeCNC2.
a. Na lista Capacity defined, clique em By home location.

A opção By home location define o número de recursos iguais ao
número de nós que você definiu para este conjunto de recursos.
b. Clique no botão de mais e adicione nodeCNC1 e nodeCNC2 à lista

Home location (nodes).
Depois que os nós forem adicionados, a lista deve parecer com a

figura abaixo.
Estamos prontos parar modificar o fluxograma que o modelo usa para definir o
comportamento dos paletes, adicionando um bloco Seize que usará as máquinas
CNC. Mais tarde, um bloco Delay simulará o processamento de matérias primas de
uma máquina CNC, e um bloco Release liberará uma máquina CNC para que ela
possa processar a matéria prima do próximo palete.
NOTA: Lembre-se que o fluxograma do nosso modelo já tem um bloco
pickRawMaterial para simular os recursos móveis (as empilhadeiras) que levam os
paletes para as máquinas CNC.
10. No fluxograma que define o comportamento dos paletes, arraste os blocos

pickRawMaterial e sink para a direita para dar espaço a um novo bloco.
11. Na paleta Process Modeling Library, arraste o bloco Seize e o insira no

fluxograma das paletas, depois do bloco rawMaterialinStorage.
11
12. Na área Properties do bloco Seize, faça o seguinte:

a. No campo Name, digite seizeCNC.
b. Sob a opção Resource sets, clique no botão mais , e depois clique

em cnc.
Completando este passo, garantimos que o bloco Seize consumirá um recurso
do conjunto de recursos cnc.
13. Na área Properties do fluxograma pickRawMaterial, faça o seguinte:
a. Na lista Destination is, clique em: Seized resource unit.
b. Na lista Resource, clique em cnc.
Este bloco simulará como os paletes serão transportados para as máquinas
CNC em uso, ao invés da área de estacionamento das empilhadeiras.
14. Faça o seguinte para simular o processamento de matérias primas nas
máquinas CNC:
a. Adicione um bloco Delay, posicione-o logo depois de pickRawMaterial
e nomeie-o processing.
14
15. Na área Properties do bloco Delay, faça o seguinte:

a. No campo Delay time, digite triangular(2,3,4) e selecione minutes na
lista à direita.
b. Marque o checkbox Maximum capacity para permitir que as
máquinas processem vários paletes.
Cada agente que chega ao bloco Delay deve ter uma das duas máquinas CNC
do nosso modelo.
16. Na paleta Process Modeling Library, arraste o bloco Release para o fluxograma
dos paletes e o coloque depois do bloco processing.
17. Nomeie este bloco Release como releaseCNC.
16
Se você executar o modelo, verá que enquanto os processos são simulados

corretamente a animação 3D desenha um palete no meio da forma da máquina
CNC. Isto ocorre quando a máquina CNC, o palete que ela está processando e o
local da animação usam o mesmo point node. Para resolver o problema,
precisaremos deslocar as máquinas CNC para a direita e girá-las para ficarem de
frente para o palete.
18. Na visão Projects, dê um clique duplo no agente CNC para abrir seu diagrama.
19. Mova a animação para a direita e gire a forma da máquina CNC usando a alça
circular, ou configurando a propriedade Rotation da figura para 90 graus.
19
Estamos prontos para usar duas formas de animação 3D para animar as máquinas
CNC: uma forma representará a máquina ociosa e a outra representará a máquina
processando matérias primas. Definiremos valores dinâmicos para a propriedade
Visible de cada forma que permitirá que o nosso modelo use o estado da máquina
CNC, para determinar qual forma o modelo exibirá em tempo de execução.
20. Faça o seguinte para alterar a configuração de visibilidade da forma de
animação CNC:
a. Selecione a forma de animação CNC.
b. Passe o mouse sobre o ícone de parâmetros estáticos que fica ao

lado do rótulo Visible e clique em Dynamic value.
O ícone muda para o ícone de propriedades dinâmicas e

aparece um campo onde você pode definir uma expressão dinâmica.
Você pode usar o campo para digitar uma expressão em Java que
retorne um valor true ou false .
c. No campo, digite isBusy()
Esta função padrão para um recurso AnyLogic retorna true quando o
recurso está ocupado. No nosso caso, a função fará a forma de animação
3D ser exibida quando a máquina CNC estiver processando matérias
primas.
20
Propriedades dinâmicas
Quando você define uma expressão para um valor dinâmico da propriedade,
nosso modelo reavaliará a expressão para cada frame da animação durante o
tempo de execução, e depois usará o valor resultante como o valor atual da
propriedade. Fornecer valores dinâmicos para a posição, altura, largura ou cor de
uma forma permite aos usuários do AnyLogic animarem seus modelos.
Se você não digita um valor dinâmico, a propriedade mantém o valor estático
padrão durante toda a simulação.
• Os blocos de fluxograma podem ter:
Static parameters que mantém o mesmo valor em toda a simulação, a não

ser que uma função set_parameterName(new value) o altere.
Dynamic properties cujo valor é reavaliado sempre que um novo agente

entra no bloco.
Code parameters que permite definir ações que serão executadas em um

momento chave no bloco do fluxograma, como as ações On enter e On exit. Na
maioria dos casos, você encontrará parâmetros de código na área Properties
de um bloco de fluxograma, na seção Actions.
• O triângulo pequeno no ícone do parâmetro indica que você pode clicar no

ícone e alternar entre o editor de valor estático e o campo onde você pode
digitar a expressão de valor reavaliado dinamicamente.
21. Faça o seguinte para adicionar mais uma forma de animação que será visível
somente quando a máquina CNC não estiver processando matérias primas.
a. Abra a paleta 3D Objects que tem os objetos 3D disponíveis do
AnyLogic.
b. Expanda a área CNC Machines e arraste a forma CNC Vertical
Machining Center 2 State 2 para o diagrama CNC .
c. Gire a forma e coloque-a diretamente em cima da primeira figura de

animação.
d. No campo Visible, alterne para o editor de valores dinâmicos, e digite
isIdle() como a expressão dinâmica para a propriedade Visible da
forma.
21
22. Expanda a seção People da paleta 3D Objects e arraste a forma Worker para o
diagrama CNC.
22
23. Execute o modelo e observe o processo.

Você verá como empilhadeiras transportam paletes para as máquinas CNC
processarem. Você também deve ver máquinas CNC animadas, mudando as
formas 3D dependendo dos seus estados.
Terminamos nosso modelo simples que simula a fabricação e o processo de

entrega de uma pequena fábrica. Agora você tem um conhecimento básico dos
recursos do AnyLogic e sabe como trabalhar com eles. Você também sabe como
usar um fluxograma construído de blocos da Process Modeling Library para
definir a lógica do processo.
Seu próximo passo pode ser modelar como os paletes com partes finalizadas são
movidos para outra área de armazenamento na plataforma de envio, onde eles
ficarão até que sejam enviados. Você já usou os blocos que precisará para modelar
esta parte do processo, assim você poderá adicionar esta lógica por conta própria.
O próximo exercício também usará um fluxograma baseado em processos, mas
desta vez será um modelo de pedestres que discutiremos a seguir.
Modelagem de Pedestres
A simulação de tráfego de pedestres é uma parte importante da construção,
expansão ou redesenho de instalações como shoppings, aeroportos, estações de
trem e estádios. Estas análises podem ajudar arquitetos a melhorarem seus
projetos, proprietários a revisarem uma mudança potencial num prédio, e
autoridades civis a simularem rotas de evacuação possíveis. Dado que fluxos de
pedestres podem ser complexos, eles exigem uma simulação bem desenvolvida.
Pedestres seguem regras básicas que têm sido determinadas por estudos teóricos
detalhados; eles se movem a taxas predeterminadas, eles evitam espaços físicos
como paredes bem como outras pessoas, e eles usam informações sobre as
pessoas em volta para ajustar suas distâncias e velocidades. Os resultados têm
sido provados muitas vezes em pesquisas de campo e aplicações de clientes.
Você pode criar métricas como o tempo de viagem total entre pontos
especificados e variar seus experimentos para destacar estas medidas durantes os
momentos de pico. Finalmente, você pode importar layouts, plantas baixas e
mapas, e criar múltiplas visões 3D que deixarão a análise do fluxo de pedestres
mais fácil de entender.
O AnyLogic pode ajudar a resolver estes problemas de tráfego de pedestres:
• Tempo e cálculo de taxa. Suponha que você esteja projetando um

supermercado, uma estação de metrô ou de trem ou um terminal de
aeroporto. Se o seu objetivo é criar um layout que minimize o tempo de
viagem e garanta que os fluxos dos pedestres não interfiram uns aos outros,
uma simulação do AnyLogic pode facilmente testar condições normais,
especiais ou de pico.
• Análise de impacto do tráfego de pedestres. Gerentes de áreas de elevado

tráfego como parques temáticos, museus e estádios podem usar uma
simulação para entender como mudanças em um novo quiosque ou um
reposicionamento de um painel de propaganda afetam suas operações, os
tempos de deslocamento dos pedestres e a experiência dos usuários.
• Análise de evacuação. O aumento da frequência de desastres naturais e

causados pelo homem torna importante avaliar e otimizar planos de
evacuação. Modelagens de situações de emergência podem ajudar as agências
de gerenciamento de riscos a desenvolverem planos de evacuação efetivos
que salvem vidas.
Modelo de aeroporto
Vamos construir um modelo que simule como passageiros se movem dentro de
um pequeno aeroporto que tem duas companhias aéreas, cada uma com seu
próprio portão. Os passageiros chegam ao aeroporto, fazem check in, passam pela
segurança e vão para a área de embarque. Depois que o embarque começa, os
representantes de cada companhia verificam as passagens dos seus passageiros
antes de deixarem eles embarcar.
Usaremos uma abordagem em seis fases para desenvolver o nosso modelo. Na
fase final, você aprenderá como ler dados de voos de uma base de dados
(disponível em uma planilha Excel) e configurar os pedestres, atribuindo
informações de voo a eles.
Fase 1. Definindo o fluxo de pedestres básico

Em nossa primeira fase, usaremos a Biblioteca de Pedestres (Pedestrian Library)
do AnyLogic para criar um modelo simples de um aeroporto onde os passageiros
chegam e depois se dirigem ao portão de embarque.
Biblioteca de Pedestres
• Os métodos de modelagem tradicionais, como eventos discretos e filas, podem
não funcionar bem em áreas de alta circulação de pedestres.
• A Biblioteca de Pedestres do AnyLogic simula os fluxos de pedestres em

ambientes “físicos” permitindo a criação de modelos de edificações e áreas
com grande número de pedestres como estações de metrô, pontos de
inspeção de segurança e ruas.
• Os pedestres do seu modelo se movimentam em um espaço contínuo enquanto

reagem a obstáculos e a si mesmos. Isto permite coletar dados sobre a
densidade de pedestres de uma determinada área, assegurar níveis de
desempenho aceitáveis para pontos de serviço com uma carga hipotética,
estimar quanto tempo os pedestres ficarão em áreas específicas e detectar
problemas potenciais que mudanças internas, como adicionar ou remover
obstáculos, podem causar.
Na maioria dos casos, você começará a criar um modelo de dinâmica de pedestres
adicionando o layout da edificação simulada e desenhando paredes sobre ele.
1. Crie um novo modelo com o nome Airport.
2. Arraste uma Image da paleta Presentation para o diagrama Main.
3. Escolha o arquivo da imagem que você quer exibir. Neste exemplo, você
selecionará a imagem terminal.png em Diretório do
AnyLogic/resources/AnyLogic in 3 days/Airport.
4. No diagrama Main, posicione a imagem no canto inferior esquerdo do frame

azul. Se a imagem estiver distorcida, clique no botão Reset to original size e
marque o checkbox Lock para bloquear a imagem.
Agora usaremos um conjunto de formas de marcação de espaço da paleta
Pedestrian Library para definir o espaço do nosso modelo de pedestres. Você pode
usar formas de marcação de espaço para desenhar paredes, serviços (locais como
catracas e bilheterias onde pedestres recebem serviços) e áreas de espera.
Formas de marcação de espaço para modelos de pedestres
A seção Space Markup da paleta Pedestrian Library

Usaremos paredes – objetos dentro do espaço simulado do nosso modelo que os
pedestres não podem atravessar – para começar a criar nosso modelo. Em termos
simples, estamos prestes a usar as três formas de marcação abaixo para colocar as
“paredes do AnyLogic” em cima das paredes que aparecem na imagem.
Paredes
Wall – Use esta forma para desenhar paredes externas ou internas.
Rectangular Wall – Use esta forma para desenhar áreas retangulares como
áreas de trabalho que não são acessíveis para pedestres.
Circular Wall - Use esta forma para desenhar obstáculos circulares como
colunas, piscinas e fontes.
5. Use a paleta Pedestrian Library para desenhar as paredes do aeroporto. Dê um

clique duplo no elemento Wall localizado na seção Space markup da paleta
Pedestrian Library e, em seguida, desenhe a parede sobre a borda do terminal
do aeroporto clicando no mouse toda vez que quiser adicionar um ponto.
Quando estiver pronto para definir o ponto final da parede, dê um clique
duplo no mouse.
Vamos mudar a aparência da nossa parede escolhendo uma nova cor e uma nova
altura.
6. Vá até as propriedades da parede e selecione Color: dodgerBlue na seção
Appearance.
Agora que definimos as paredes do aeroporto e escolhemos sua cor, usaremos o

elemento especial de marcação de espaço Linha de Destino (Target Line) para
garantir que os pedestres do nosso modelo apareçam na entrada do aeroporto e
que sigam em direção aos portões.
Linhas de Destino
Em um modelo de dinâmica de pedestres, o elemento Linha de Destino define os
locais onde os pedestres aparecem no espaço simulado, onde eles esperam
(embora áreas normalmente definam locais de espera) e seus destinos.
7. Defina o local onde os passageiros do seu modelo aparecem arrastando o
elemento Target Line da paleta Pedestrian Library para o diagrama gráfico,
como mostrado na figura abaixo.
8. Nomeie a linha de destino como arrivalLine.

9. Defina uma segunda linha de destino para onde os passageiros irão depois de
entrarem no aeroporto, coloque-a na área do portão, como mostrado na
figura abaixo, e nomeie-a gateLine1.
 Os elementos de linha de destino e as formas de marcação de espaço do seu

modelo devem ficar no interior do terminal. Se uma das formas de marcação
de espaço do seu modelo tocar uma parede, a messagem de erro “Exception
during the discrete event execution: Unreachable target…” pode ser exibida
em tempo de execução do modelo.
Marcamos o espaço que define nosso modelo de pedestres, e agora usaremos um

fluxograma para definir a lógica de processos do modelo.
Definindo a lógica do fluxo de pedestres usando os blocos de

fluxograma da Biblioteca de Pedestres
Você usará um fluxograma para definir os processos que acontecem em seus
modelos de dinâmica de pedestres. Os pedestres do seu modelo passam por um
fluxograma e realizam operações definidas pelos blocos.
Os blocos mais importantes da Pedestrian Library são:
PedSource – Este bloco gera pedestres de uma forma parecida com a que o
Source usa para gerar agentes em um fluxograma da Biblioteca de Modelagem
de Processos. Você geralmente usará este bloco como o ponto de partida do
fluxo de pedestres.
PedGoTo – Este bloco faz os pedestres irem para um destino especificado.
PedService – Este bloco simula como os pedestres recebem os serviços em

pontos de serviço.
PedWait – Este bloco faz os pedestres esperarem por um tempo

determinado, em um local especificado.
PedSelectOutput – Este bloco usa condições especificadas para direcionar

os pedestres que chegam, para vários caminhos ou processos.
PedSink – Este bloco descarta os pedestres e é geralmente o ponto final do

fluxo de pedestres.
10. Comece arrastando o bloco PedSource da paleta Pedestrian Library para o
diagrama do tipo de agente Main.
10
11. Como queremos que os passageiros cheguem aleatoriamente a uma taxa

média de 100 passageiros por hora, vá para as propriedades do bloco
pedSource e digite 100 no campo Arrival rate.
12
11
12. Especifique o local onde os passageiros aparecem no sistema simulado

clicando em arrivalLine na lista Target line.
13. Adicione um bloco PedGoTo para simular a movimentação dos pedestres para
o local especificado e conecte-os ao pedSource. Como queremos que os
passageiros se dirijam ao portão, nomeie o objeto de goToGate1.
Para conectar os blocos, adicione um novo bloco da paleta para o diagrama
gráfico e o posicione perto do outro bloco.
13
14. Especifique o destino selecionando gateLine1 na lista Target line.

14
15. Adicione um bloco PedSink para descartar os pedestres que chegam. O fluxo
de pedestres normalmente começa com um bloco PedSource e termina com
um bloco PedSink.
15
Seu fluxograma deve parecer com o da figura acima.

16. Execute o modelo. Na animação 2D, você verá que os pedestres se movem da
entrada do aeroporto para o portão.
16
Fase 2. Desenhando animações 3D

Vamos adicionar animações 3D ao nosso modelo, adicionando elementos 3D
específicos (janela 3D, câmera) e um modelo 3D de um passageiro. Começaremos
atribuindo uma forma de animação 3D personalizada para o passageiro, uma
decisão que significa que precisamos criar um Pedestrian type personalizado.
 Se você quiser adicionar animações 3D, atributos personalizados, ou coletar

estatísticas dos pedestres, você deve criar um tipo de pedestre
personalizado.
1. Da paleta Pedestrian Library, arraste o elemento Pedestrian Type para o

diagrama Main.
2. No assistente New agent, no campo Agent type name, digite Passenger e clique
em Finish.
3. Depois que o diagrama Passenger abrir, retorne ao diagrama Main.
4. Da paleta Presentation, arraste a Camera para o diagrama Main e a posicione

de frente para o terminal.
5. Arraste a 3D Window para o diagrama Main e a posicione abaixo do layout do

terminal.
6. Abra as propriedades da 3D Window, e selecione a câmera na lista Camera.

7. Queremos que o bloco pedSource crie pedestres do tipo personalizado

Passenger. Abra as propriedades do pedSource, e selecione Passenger no
campo New pedestrian na seção Pedestrian.
8. Execute o modelo, e você verá pedestres se moverem da entrada para o
portão, para dentro do terminal. Você pode mudar para uma visão 3D
clicando no botão Navigate to view area… da barra de ferramentas e
selecionando [window3d] na lista.
Você pode usar o mouse para navegar em 3D em tempo de execução.

Navegação no cenário em 3D
• Mova a câmera para a esquerda, para a direita, para frente ou para trás
arrastando o mouse na direção selecionada.
• Mova a câmera para mais perto ou mais longe do centro da cena girando o
scroll do mouse.
• Gire a cena em relação à câmera arrastando o mouse enquanto a tecla ALT e

o botão esquerdo do mouse estão sendo pressionados.
9. Navegue pelo cenário para obter a melhor perspectiva, clique no botão direito
(Mac OS: CTRL+clique) dentro do cenário 3D, e depois clique em Copy the
camera’s location.
10. Feche a janela do modelo, abra as propriedades da câmera, e depois aplique a

melhor perspectiva selecionada durante o passo anterior, clicando em Paste
coordinates from clipboard.
10
Se não conseguir localizar a câmera, use a árvore de Projects para localizá-la. Você
a encontrará sob o ramo Presentation do agente Main do aeroporto.
11. Execute o modelo uma segunda vez e veja a visão 3D que a posição da nova
câmera proporciona.
Fase 3. Adicionando pontos de inspeção de

segurança
Nesta terceira fase, começaremos a modelar os processos que acontecem dentro
do aeroporto adicionando pontos de inspeção de segurança. Todos os pontos de
inspeção são pontos de serviço.
Serviços nos modelos de pedestres

Em simulações de fluxo de pedestres, os serviços são objetos – como as catracas,
caixas, bilheterias e máquinas de tíquetes – onde os pedestres recebem serviços.
Se um serviço está em uso, os outros pedestres esperarão em um fila até que ele
fique disponível.
Você precisará completar um processo de dois passos para definir os serviços que
os pedestres do seu modelo usarão. O primeiro passo é usar as formas de
marcação Service with Lines e Service with Area para desenhar os serviços do seu
modelo de pedestres.
• Service with Lines – Esta forma de marcação define um serviço como uma
catraca ou uma área de checkout onde pedestres esperam em uma fila até que
o serviço esteja disponível.
• Service with Area – Esta forma de marcação define um serviço como uma
bilheteria ou um banco com uma fila eletrônica onde pedestres esperam em
uma área ao lado até que o serviço esteja disponível.
Depois de desenhados os serviços do seu modelo, você definirá a lógica de fluxo
de pedestres adicionando o bloco PedService da Biblioteca de Pedestres ao
fluxograma.
Adicionaremos cinco pontos de inspeção, o que significa que adicionaremos cinco
serviços e cinco filas para cada ponto de serviço.
1. Arraste o elemento Service with Lines da paleta Pedestrian Library para o
layout do terminal. Por padrão, um serviço terá dois pontos de serviço e duas
filas que levam aos pontos de serviço.
2. Abras as propriedades do Service With Lines, use o campo Name para nomear
a forma scpServices - neste caso, “scp” significa security checkpoints – e
depois mude o Type of service para Linear.
Depois que mudar o tipo de serviço de pontual para linear, as formas de serviço
mudarão de pontos para linhas.
Serviços lineares e pontuais em modelos de pedestres

Um serviço de pedestres poder ser linear ou pontual.
• Em um serviço linear como a catraca, os pedestres se movem continuamente
do ponto inicial da fila até o ponto final da fila.
• Em um serviço pontual como uma bilheteria, os serviços de pedestres ocorrem

em um ponto específico onde os pedestres esperam por um tempo de atraso
determinado.
Estamos usando um serviço linear para garantir que os passageiros do nosso
modelo andem ao longo da fila de serviço e passem pelo detector de metais do
ponto de inspeção. Agora, garantiremos que o ponto do serviço linear cruze
verticalmente o marcador de área que representa o detector de metais.
3. Use a alça circular sobre o centro da forma para girar o serviço.
4. Mova o serviço de um modo que o primeiro serviço linear cruze o retângulo

que representa o frame do detector de metais.
Como mover elementos ignorando a grade

Se você quiser mover um elemento sem automaticamente alinhar o elemento à
grade, segure o ALT ao mover o elemento ou use o botão Enable/Disable Grid da
barra de ferramentas para desabilitar a grade.
5. Selecione a próxima fila de serviço.
Formas compostas de marcação de espaço

As formas compostas de marcação de espaço são formadas por vários
componentes. Por exemplo, a forma Service with Lines é composta pelas formas de
marcação de espaço Service e Queue Line, enquanto que a forma Service with Area
é composta das formas Service e Polygonal Area.
Você precisará prestar muita atenção a estas regras enquanto trabalha com
formas de marcação de espaço compostas:
• O seu primeiro clique selecionará toda a forma de marcação de espaço

composta (Service with Lines).
• Depois que selecionar a forma de marcação de espaço composta, você pode

clicar em qualquer componente para selecioná-la (Service ou Queue Line).
6. Cuidadosamente, coloque a fila de serviço em cima do segundo marcador de
espaço do ponto de inspeção e ajuste o local da fila.
7. Navegue até as propriedades da forma Service with Lines e mude ambos

Number of services e Number of lines para 5.
8. Se necessário, ajuste o novo serviço e as filas. Depois de completado este

passo, as formas de serviço devem parecer como as da figura abaixo.
Agora que desenhamos os serviços, adicionaremos eles à lógica do nosso modelo.

Usaremos um bloco especial da Pedestrian Library chamado PedService para
simular como os passageiros passam pelos serviços de ponto de inspeção.
9. Adicione o bloco PedService ao fluxograma entre os blocos PedSource e
PedGoTo para fazer os pedestres passarem pelo serviço que definimos
usando a forma Service with Lines referenciada, e depois a nomeie como

securityCheck.
10. Vá para as propriedades do bloco securityCheck. Selecione os serviços

scpServices como Services.
11. Como assumimos que leva de 1 a 2 minutos para passar pelo ponto de
inspeção, digite uniform(1, 2) minutes como o Delay time.
12. Agora vamos adicionar modelos 3D dos pontos de inspeção. Usando a paleta
3D Objects, os elementos Metal Detector e XRay Scanner da seção Airport,
desenhe cinco pontos de inspeção. Mude a Scale das formas XRay Scanner
para 75%.
13. Execute o modelo. Você verá que agora os passageiros são escaneados nos
pontos de inspeção de segurança.
Fase 4. Adicionando as instalações de check-in

Estamos prontos para simular as instalações de check-in do aeroporto de uma
maneira que represente os vários modos que os passageiros podem fazer check in
dos seus voos.
1. Desenhe pontos de check-in com outra forma Service with Lines. Desta vez,
adicionaremos quatro pontos de serviço e uma fila. Nomeie os serviços como
checkInServices.
2. Coloque a forma no local mostrado na figura abaixo. Para fazer a linha parecer
com o que você vê na figura, mova a linha para o local requerido, e depois
coloque o ponto final onde a linha começa uma curva.
3. Adicione mais pontos de curva à linha. Clique com o botão direito na linha da
fila, escolha Add points no menu de contexto, e depois clique no ponto final da
linha de onde você quer continuar a desenhar a linha.
4. Adicione mais pontos clicando onde você quer colocar os pontos de curva da
linha. Finalize o desenho da linha dando um duplo clique. Finalmente você
deve ter a linha da fila da seguinte forma:
5. Adicione outro bloco PedService e o nomeie como checkInAtCounter.

6. Nas propriedades do bloco, selecione a forma de marcação de espaço

checkInServices como Services.
7. Como assumimos que leva de 2 a 4 minutos para fazer o check in, digite
uniform(2, 4) minutes como Delay time.
8. Adicione o bloco PedSelectOutput para direcionar os passageiros para

diferentes ramos do fluxograma.
9. Conecte o bloco checkInAtCounter aos blocos do fluxograma existente, como

mostrado na figura abaixo.
Como desenhar conectores

Os blocos de fluxograma do seu modelo automaticamente se conectarão quando
você colocá-los pertos uns dos outros, mas você também pode usar um conector
para conectar blocos manualmente. Para desenhar um conector, dê um clique
duplo na porta do primeiro bloco e depois clique na porta do outro bloco. Se você
precisar adicionar uma curva na linha de conexão, adicione-a com um clique.
Depois que desenhar o conector, você pode adicionar pontos de curva dando
cliques duplos no conector e arrastando os pontos que aparecem. Para remover
um ponto de curva, dê um clique duplo sobre ele.
10. Como estamos assumindo que 30 por cento dos nossos passageiros farão
check in online e 70 por cento no local, modelaremos este comportamento
configurando Probability1: para 0.3 e Probability 2: para 0.7 do
pedSelectOutput. Esta ação levará 30 por cento dos passageiros para o ramo
superior do fluxograma e 70 por cento dos passageiros para o ramo inferior.
Você deve configurar Probability 3, Probability 4, e Probability 5 para 0 para
prevenir o AnyLogic de direcionar passageiros para as três últimas portas de
saída do bloco.
11. Vamos adicionar os modelos 3D disponíveis para a área de check-in do

aeroporto. Na aba 3D Objects da paleta, expanda a seção People, e adicione
duas cópias de ambos Office Worker e Woman 2 ao diagrama.
12. Na aba 3D Objects da paleta, selecione a seção Office, e arraste quatro cópias
do objeto Table para o diagrama. Como as tabelas não estão apontando para a
direção correta, use suas áreas Position da seção Properties para definir
Rotation, Z: 90 degrees.
12
13. Execute o modelo. Você verá alguns passageiros fazerem check in e depois
passarem pelo detector de metais.
Agora adicionaremos barreiras que são comuns em áreas onde passageiros fazem
check in dos seus voos.
14. Use o elemento de marcação de espaço Wall para desenhar duas barreiras.
14
15. Mude a Color da parede para dodgerBlue, a Line width para 1, Z: 5 e Z-Height:
5.
Nós queremos que os passageiros aguardem antes deles irem para o portão. Para
fazer isso, precisamos desenhar uma área de embarque onde os passageiros
aguardarão e depois adicionaremos um bloco (PedWait) para simular a espera.
16. Desenhe a área de embarque antes dos portões usando o elemento Polygonal
Area da seção Space Markup da paleta Pedestrian Library. Alterne para o
modo desenho e desenhe a área como mostrado na figura abaixo clicando
toda vez que quiser adicionar um ponto. Quando acabar, dê um clique duplo.
17. Adicione o bloco PedWait ao fluxograma, entre PedService e PedGoTo.
17
18. Modifique as propriedades do bloco selecionando a área na lista Area, e

depois configure o Delay time para uniform(15, 45) minutes.
19. Execute o modelo novamente, você verá que os passageiros agora levam em
consideração as barreiras, e aguardam na área de embarque antes de
procederem para o portão.
Você pode adicionar mais instalações de check-in à direita e configurar o

PedSelectOutput para dividir o fluxo de pedestres em mais ramos.
? Como simular máquinas de check-in automático (totens)?

Fase 5. Definindo a lógica de embarque

Nesta fase, simularemos os processos que acontecem no portão de embarque do
nosso aeroporto. O ponto de verificação de passagens que cada passageiro deve
passar antes de embarcar no avião tem uma fila para passageiros da classe
executiva – que são servidos primeiro – e outra para passageiros da classe
econômica. Adicionaremos informações personalizadas aos pedestres para
distinguir os passageiros da classe executiva dos passageiros da classe econômica.
1. Na árvore Projects, abra o diagrama do agente Passenger dando um clique
duplo no item Passenger.
2. Adicione um Parameter da paleta Agent para definir a classe do passageiro.
Nomeie-o de business, e defina Type: Boolean. Se o parâmetro é igual a true,
este é um passageiro da classe executiva, caso contrário (se o parâmetro é
false), este é um passageiro da classe econômica.
Queremos diferenciar os passageiros nas animações 3D, ou seja, animar os

passageiros da classe executiva e de negócios com modelos 3D diferentes. Para
fazer isso, usaremos o objeto existente Person 3D para representar os passageiros
da classe econômica e adicionar outra forma 3D para representar os passageiros
da classe executiva.
3. Adicione o objeto 3D Office worker para animar um passageiro da classe
executiva e coloque a figura no ponto de origem dos eixos (0,0), à direita da
forma Person.
4. Mude a visibilidade desses objetos. Primeiro, clique na forma Office worker .

Queremos que esta forma seja visível somente quando o passageiro for da
classe executiva, isto é, quando seu parâmetro business for igual a true.
Alterne para o editor de valor dinâmico da propriedade Visible clicando no
ícone à direita do rótulo Visible, e depois digite business no campo.
Fazendo isso, estamos tornando esta forma 3D visível somente quando o
parâmetro business é igual a true.
5. Agora selecione o objeto person 3D (você pode fazer isso usando a árvore de
Projects), e defina Visible: ! business . Esta forma será visível somente se o
passageiro for da classe econômica.
O símbolo ! é o operador booleano de NEGAÇÃO. A expressão !business
retorna true quando business NÃO é true – quando o passageiro não é da
classe executiva e sim da classe econômica.
Nós queremos definir a classe dos passageiros quando eles chegam ao terminal do
aeroporto.
6. Retorne ao diagrama Main e adicione uma Function da paleta Agent, com nome
setupPassenger.
7. Configure a função como segue:

• Crie um argumento para passar o passageiro recém-criado para a função:

Name: ped
Type: Passenger
• O código da função define a frequência com que os passageiros da classe

executiva aparecem no modelo:
ped.business = randomTrue(0.15);
Neste caso, ped é o argumento da função, de tipo Passenger. Definindo Passenger

como o tipo do argumento, podemos acessar diretamente o campo business do
pedestre simplesmente como ped.business. A função randomTrue(0.15) retorna
true em uma média de 15 por cento dos casos, o que significa que uma média de
15 por cento dos passageiros do nosso modelo viajarão na classe executiva.
8. Chame esta função quando um novo pedestre é criado pelo bloco pedSource.
Nas propriedades do pedSource, clique na seta para expandir a seção Actions,
e digite o código a seguir no campo On exit: setupPassenger(ped);
Aqui chamamos a função setupPassenger para um pedestre recém-criado. Este

pedestre é passado para função por argumento.
Desenhe dois serviços com filas para o portão superior, uma para os passageiros
da classe executiva e outro para os da classe econômica.
9. Desenhe um Service with Line, definindo a fila de prioridade (serviço
pontual, 1 serviço, 1 fila). Nomeie este serviço business1.
10. Adicione mais um Service with Line, e o nomeie economy1.

10
11. Desenhe uma área no portão com o elemento Rectangular wall, e depois
adicione uma mesa e dois modelos 3D woman à mesa.
11
Insira os blocos no fluxograma entre os objetos pedWait e goToGate1.

12. Adicione um PedSelectOutput para direcionar os passageiros das classes

executiva e econômica para filas diferentes.
13. Adicione dois blocos PedService: businessBoarding1 e economyBoarding1 para

simular o processo de verificação das passagens dos passageiros no portão.
14. Como o bloco PedSelectOutput direciona os passageiros das classes executiva
e econômica para filas diferentes, selecione Use: Conditions, e digite
ped.business no campo Condition 1. Esta expressão retornará true para todos
os passageiros da classe executiva, o que significa que eles seguirão o ramo
superior do fluxograma e se juntarão a fila de prioridade. Depois que você
definir as condições para as próximas portas de saída do bloco (true , false,
false), o modelo direcionará todos os outros passageiros para a segunda porta
de saída.
14
15. Para o bloco PedService businessBoarding1, escolha business1 como Services.

Como leva de dois a cinco segundos para verificar a passagem de um
passageiro, você pode mudar um pouco (diminuir) o Delay time.
16. Para economyBoarding1, defina Services: economy1, ajuste o Delay time.
17. Execute o modelo. Você verá os passageiros passarem pelo ponto de
verificação, e um número pequeno deles indo pela fila de prioridade.
Fase 6. Configurando voos do Excel

Nesta fase, modelaremos como os aviões decolam em tempos específicos de
acordo com um horário armazenado em uma base de dados. Começaremos
criando o tipo de agente Flight que permitirá que o nosso modelo armazene
informações de voos.
1. Adicione uma população de agentes vazia do novo tipo de agente Flight,
arrastando o elemento Agent da paleta Agent para o diagrama Main.

a. Selecione Population of agents.
b. Selecione a opção I want to create a new agent type. Clique em Next.
c. Especifique Agent type name: como Flight. O nome da população será
preenchido como flights. Clique em Next.
d. Como não precisamos animar os voos, selecione None para a animação.
Clique em Next.
e. Pule os passos de criação de parâmetros. Clique em Next.
f. Selecione Create initially empty population... para permitir usar dados
da base de dados para adicionar voos programaticamente.
g. Clique em Finish.
3. Na visão Projects, dê um clique duplo em Flight para abrir seu diagrama. No

diagrama Flight, crie três tipos diferentes de parâmetros que armazenarão o
tempo de partida, destino e número do portão do voo.
• departureTime. Na lista Type, clique em Other…, e depois digite Date no

campo à direita.
• destination, Na lista Type, clique em String.
• gate, Na lista Type, clique em int.
4. Use a paleta Agent para adicionar uma Collection com o nome passengers , e
depois defina Collection class como LinkedList, e Elements class como
Passenger. Esta coleção armazenará a lista de passageiros que compraram as
passagens para o voo.
Coleções
Coleções (Collections) definem objetos de dados que agrupam múltiplos
elementos em uma estrutura para armazenar, recuperar e manipular dados
agrupados. Elas normalmente representam itens de dados que formam um grupo
natural.
5. Agora que criamos o agente Flight, adicionaremos um parâmetro flight ao
diagrama Passenger e definiremos Type como Flight. Este parâmetro
armazenará o voo do passageiro.
6. Retorne ao diagrama Main e adicione um parâmetro para definir a duração do

tempo de embarque. Nomeie o novo parâmetro como boardingTime, e depois
escolha Type: Time, Unit: minutes, e Default value: 40 .
7. Selecione a função setupPassenger que criamos anteriormente para completar

o processo de configuração. A função agora usa a função random() para
selecionar aleatoriamente o voo que o passageiro fará, na lista de voos
disponíveis. O voo é armazenado no parâmetro flight do passageiro, e o
AnyLogic adiciona o passageiro à coleção de passageiros que pegarão o
mesmo voo. Modifique o código na seção Function body:
A função dateToTime() converte a data fornecida para o tempo do modelo em

relação a data inicial, e as configurações de unidade do tempo do modelo. A
função add() adiciona um elemento a coleção.
Trabalhando com os dados da coleção

Você pode usar as funções a seguir para manipular os dados da coleção:
• int size() – Retorna o número de elementos da coleção.
• boolean isEmpty() - Retorna true, se a coleção não tem elementos; false, caso
contrário.
• add(element ) – Adiciona o elemento especificado ao final da coleção.
• clear() – Remove todos os elementos da coleção.
• get(int index) – Retorna o elemento da posição especificada na coleção.
• boolean remove(element) – Remove o elemento especificado da coleção, se ele

existir. Retorna true se a lista continha o elemento especificado.
• boolean contains(element) - Retorna true se a coleção contém o elemento

especificado.
8. Arraste o elemento Excel File da paleta Connectivity.
A paleta Conectividade
A paleta Connectivity tem um conjunto de ferramentas de fácil uso que você pode
usar para acessar dados externos.
Excel File – Proporciona acesso a arquivos do Excel (.xsl, .xslx). Permite ler e escrever
arquivos usando a API fornecida.
Text File – Permite ler e escrever arquivos de texto usando as funções do elemento.
Database – Conecta-se a bases de dados, como Microsoft Access e Microsoft SQL

Server, bem como bases de outros fabricantes.
O AnyLogic Professional fornece um conjunto de ferramentas que simplificam o trabalho

com Database (veja abaixo) permitindo usar propriedades visuais para criar consultas
SQL frequentemente usadas. Se você tem outra edição do AnyLogic, você pode realizar as
mesmas tarefas criando suas próprias consultas SQL e usando a API Database.
Query – Preenche uma população de agentes com agentes cujos atributos são lidos a
partir de uma tabela.
Key-Value Table – Carrega uma tabela <key,value> da base de dados e permite que os
usuário a acessem.
Insert – Insere uma linha em uma tabela.
Update – Atualiza uma linha em uma tabela; a linha é identificada por uma chave.
9. Abra as propriedades do excelFile e depois clique em Browse para adicionar o

arquivo Flights.xlsx. Você selecionará o arquivo em Diretório do
AnyLogic/resources/AnyLogic in 3 days/Airport.
Leremos os dados do arquivo Excel para configurar os voos e usar um diagrama

de ação para definir este algoritmo.
Diagramas de ação
• Modelagens de simulação complexas exigem algoritmos que realizem
processamento de dados ou cálculos. O AnyLogic suporta diagramas de ação
(action charts) – gráficos de blocos estruturados que permitem definir
algoritmos graficamente em um estilo que se assemelha a programação
estruturada.
Usamos uma extensão bem conhecida de uma abordagem sugerida por
Dijkstra que divide os algoritmos em subseções com um único ponto de
entrada. Ela estabelece que três formas de combinar programas—sequencial,
seleção, e iteração—são suficientes para expressar qualquer algoritmo
computável. O estilo resume o entendimento de um algoritmo ao
entendimento de sua estrutura.
• Diagramas de ação são muito úteis, e você pode usá-los para definir
algoritmos mesmo se não estiver familiarizado com a sintaxe dos operadores
em Java.
• Embora os diagramas de ação definam visualmente uma função, você também

pode usar as funções padrões do AnyLogic. Contudo, diagramas de
ação também ajudam a visualizar o algoritmo implementado e a torná-lo mais
fácil para outros usuários entenderem.
10. Abra a paleta Actionchart, arraste o elemento Action Chart para o diagrama
Main, coloque-o à esquerda do eixo Y, e depois o nomeie de setupFlights.
Como o diagrama de ação não retorna dados e não tem argumentos, você não
precisa mudar as configurações padrões do elemento.
10
11. Adicione uma Local Variable. Para inserir um bloco, arraste-o sobre o
diagrama de ação, e depois o solte quando ver que o AnyLogic destacou a área
reservada para inserção em azul turquesa, como mostrado na figura abaixo.
11
12. Você usará esta variável local para guardar o nome da planilha do Excel.
Percorrendo uma população de agentes usando o loop “for”

Os dois formatos de loop “for” são as formas mais simples do AnyLogic passar
pelos agentes da população:
Sintaxe Exemplo
Baseada em índice: for( int i=0; i<group.size(); i++ ) {

Object obj = group.get( i );
for( <inicialização>; <condição>;
if( obj instanceof ShapeOval ) {
<incremento> ) {
ShapeOval ov = (ShapeOval)obj;
<instruções executadas para cada
ov.setFillColor( red );
elemento>
}
}
}
Iterador de Coleção: for( Product p : products ) {

for( <tipo do elemento> <nome> : if( p.getEstimatedROI() < minROI )
<coleção> ) { p.kill();
<instruções executadas para cada }
elemento>
}
13. Insira o Loop For no diagrama de ação e, em seguida, ajuste o loop para contar
até 12 para refletir as 12 entradas de dados da planilha.
13
14. Adicione outra Local variable dentro do loop for para configurar os voos.
Criando um voo adicional e usando a função add_<populationName> do
AnyLogic para adicioná-lo à população flights, permitimos que a variável local
f armazene a referência para o agente recém-criado Flight .
14
15. Finalmente, insira o Código abaixo dentro da área do Loop For para definir o
código que lê os dados do arquivo Excel selecionado. No campo Code, digite o
seguinte:
f.destination = excelFile.getCellStringValue (sheet, i+2, 1);
f.departureTime = excelFile.getCellDateValue (sheet, i+2, 2);
f.gate = (int)excelFile.getCellNumericValue (sheet, i+2, 3);
O código usa getCellStringValue() para ler o texto da planilha. Ele começa obtendo
o destino do voo na primeira coluna, e depois o atribui ao parâmetro destination
do agente flight. O código então se move para as colunas seguintes da planilha
para obter o horário de partida e o número do portão do voo.
15
Lendo dados de arquivos Excel

As funções do elemento Excel File do AnyLogic permitem trabalhar com arquivos
Excel, e a tabela a seguir lista os métodos mais comuns para leitura de dados. Você
deve usar o tipo de dado armazenado na célula para determinar a função

getCellxxxValue() correta a ser chamada.
getCellNumericValue() – Retorna o valor numeric de uma célula.

getCellStringValue() – Retorna o valor textual (String) de uma célula.
getCellBooleanValue() - Retorna o valor lógico (Boolean) de uma célula.
getCellDateValue() – Lê a Data de uma célula.
readTableFunction() – Lê os dados da planilha para uma função tabela.
getSheetName() – Obtém o nome da planilha especificada.
cellExists() – Determina se uma célula especificada existe.
Formas de especificar uma célula

Geralmente as funções têm três notações na forma como a célula é acessada:
Argumentos A célula é acessada usando… Exemplo
int sheetIndex, * 3 números getCellNumericValue(1,

int rowIndex, 1, 3)
int columnIndex
String * Nome da planilha e 2 números getCellStringValue(“She

sheetName, et1”, 1, 3)
int rowIndex,
int columnIndex
String Um nome no seguinte formato: getCellDateValue(“Sheet

sheetName <nomePlanilha>!<nomeColuna> 1!A3”)
<nomeLinha>
O nome da planilha pode ser
omitido, neste caso é assumida
a primeira planilha.
* Observe que o Sistema de numeração do Excel para linhas e colunas

começa em 1, e não em 0.
16. Defina o segundo portão:

• Adicione dois elementos Service with lines: business2 e economy2.
• Desenhe a parede retangular, mesa e as figuras das mulheres.
• Desenhe a Target line gateLine2.
16
17. Adicione mais dois blocos PedService, businessBoarding2 e

economyBoarding2, que saem de PedSelectOutput e vão para PedGoTo. Deixe
PedSelectOutput direcionar os passageiros para quatro portas diferentes.
18. Adicione outro bloco PedGoTo para modelar como os passageiros se movem
para o segundo portão. Selecione gateLine2 como Target line do bloco.
19. Para businessBoarding2, defina Services: business2. Para economyBoarding2,
defina Services: economy2. Para ambos, defina Service time: uniform(2, 5)
seconds.
20. Com os voos configurados, podemos mudar as condições do
pedSelectOutput1 que definem qual portão os nossos passageiros selecionam.
20
Eventos dinâmicos
Agora usaremos eventos dinâmicos que agendam as ações definidas pelos
usuários do modelo para programar ações de embarque e partida. Um modelo
pode ter várias instâncias do mesmo evento dinâmico programadas
concorrentemente, e elas podem ser inicializadas por dados que estão
armazenados nos parâmetros do evento.
Você deve usar eventos dinâmicos no seu modelo:
• Quando você esperar que vários eventos, desempenhando ações

similares, sejam programados ao mesmo tempo.
• Quando a ação do seu evento dinâmico depender de uma informação

específica.
 NOTA: Como o AnyLogic representa um evento dinâmico como uma

classe Java, o nome do seu evento dinâmico deve inciar com letra
maiúscula.
21. Adicione dois elementos Dynamic Event da paleta Agent para o diagrama
Main.
21
22. O evento dinâmico DepartureEvent agenda a partida de um avião removendo

o voo da população de agentes que contém os próximos voos. Use a figura
abaixo para ajudar a configurar o evento.
23. Um segundo evento dinâmico, BoardingEvent, agenda o embarque no avião e

depois cria uma instância do evento dinâmico DepartureEvent que programa
o voo para partir em 40 minutos.
Você cria uma instância de um evento dinâmico chamando o método

create_<DynamicEventName> . No nosso caso, estamos usando a função
create_DepartureEvent() para criar uma instância do evento dinâmico que
nomeamos de DepartureEvent.
24. Mude o parâmetro Delay ends do bloco pedWait de On delay time expiry para
On free() function call para assegurar que os passageiros que precisam
esperar para embarcar em seus aviões aguardem pelo anúncio na área de
embarque.
25. Defina uma Function startBoarding para modelar o início do processo de

embarque no avião. Esta função percorre os passageiros que estão esperando
para embarcar em um voo e permite que eles embarquem finalizando seus
atrasos no bloco pedWait, com a chamada da função free() do bloco.
Neste exemplo, estamos usando um Loop For para iterar pela coleção passengers
definidas em flight. Os passageiros que estão embarcando no avião precisam
deixar a área de embarque.
26. Defina uma função planBoardings para programar o embarque de todos os
voos registrados. A função itera sobre a população de agentes flights no loop
For. Ela permite que voos que foram agendados para decolar antes do tempo
de embarque mudem para iniciar o embarque imediatamente. Voos que não
satisfazem esta condição começarão seus processos de embarque 40 minutos
antes do horário de partida como definimos no parâmetro boardingTime.
O operador if verifica a condição especificada. Se o embarque do voo

selecionado está começando, programamos a partida, e permitimos o
embarque chamando a função startBoarding (passando a referência para este
voo como argumento da função). Caso contrário, programamos
BoardingEvent.
27. Na área Agent actions de Main, no campo On startup, adicione as chamadas

para as funções setupFlights() e planBoardings().
Precisamos vincular o ponto de início da simulação a uma data específica dentro

do arquivo Excel que define os horários de partida.
28. Em Projects, selecione Simulation. Na seção Model time das propriedades do
experimento, defina Start date para 21/12/2014, 12:00:00. Na lista Stop,
clique em Stop at specified date e depois defina Stop date para 21/12/2014,
22:00:00.
29. Use a paleta Pictures para adicionar um elemento Clock que exibirá a data do
modelo.
29
30. Execute o modelo. Você verá que os passageiros aguardam pelo anúncio de
embarque na área de embarque e depois vão para os portões.
Você pode achar este modelo mais complexo do que aqueles mostrados
anteriormente, especialmente depois que mostramos como usar o AnyLogic para
definir a lógica personalizada que se baseia em eventos, funções e diagramas de
ação.
Para ir para o próximo passo no desenvolvimento dos seus projetos de simulação,
recomendamos usar a Ajuda do AnyLogic bem como os modelos de exemplo que
demonstram técnicas de modelagem específicas. Conforme você avalia o
AnyLogic, você pode usar o botão Get Support para entrar em contato com a
equipe de suporte. Eles ficarão felizes em responder as suas dúvidas sobre o
AnyLogic e ajudar a resolver qualquer problema que pode ocorrer enquanto você
desenvolve seus modelos.
Referências
Borshchev, A. (2013). The Big Book of Simulation Modeling. Multimethod modeling
with AnyLogic 6. AnyLogic North America.
Compartmental models in epidemiology. (s.d.). Último acesso em 1/06/2014,
Wiki: http://en.wikipedia.org/wiki/Compartmental_models_in_epidemiology
Conway's Game of Life. (s.d.). Último acesso em 15/05/2014, Wiki:
http://en.wikipedia.org/wiki/Conway's_Game_of_Life
Geer Mountain Software Corporation (2002) Stat::Fit (Version 2) [Software]. Geer
Mountain Software Corporation. Disponível em: http://www.geerms.com
Oracle. (2011). Java™ Platform, Standard Edition 6. API Specification. [Online].
Disponível em: http://docs.oracle.com/javase/6/docs/api/ [Acessado em
23/05/2013]
Random number generator. (s.d.). Último acesso em 29/06/2014, Wiki:
http://en.wikipedia.org/wiki/Random_number_generator
Sterman,J. (2000). Business dynamics : Systems thinking and modeling for a
complex world. New York: McGraw.
Sun Microsystems, Inc. (1999). Code Conventions for the Java TM Programming
Language. [Online]. Disponível em: http://www.oracle.com/technetwork/java/
javase/documentation/codeconvtoc-136057.html [Acessado em 23/05/2014]
System Dynamics Society, Inc. (2014). System Dynamics Society [Online].
Disponível em: www.systemdynamics.org [Acessado em 23/05/2014]
The AnyLogic Company. (2014). AnyLogic Help. [Online]. Disponível em:
http://www.anylogic.com/anylogic/help/
The Game of Life. (s.d.). Último acesso em 15/06/2014, Wiki:
http://en.wikipedia.org/wiki/The_Game_of_Life
UML state machine. (s.d.). Último acesso em 15/06/2014, Wiki:
http://en.wikipedia.org/wiki/UML_state_machine

Anylogic 7 em Tres Dias

Diunggah oleh

Informasi Dokumen

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Anylogic 7 em Tres Dias

Diunggah oleh

Hak Cipta:

Format Tersedia

Ilya Grigoryev

© Copyright 2015 Ilya Grigoryev. Todos os direitos reservados.

Sobre a segunda edição

• Todos os exemplos foram atualizados para atender à última versão do

• Um novo modelo de fábrica baseado em eventos discretos foi incluído.

Por favor, deixe-me saber como posso melhorar o livro.

Modelagem de Pedestres .............................................................................................................. 191

 As fases de construção do modelo – mapeamento do mundo real para o

modelagem – são todas menos formais do que o processo de usar modelos

Depois de construirmos o modelo – e, às vezes, quando estamos construindo –

 A modelagem consiste em encontrar o caminho do problema para a solução

Modelagem analítica vs. modelagem de simulação

Modelo Analítico (A planilha do Excel)

A tecnologia por trás da modelagem baseada em planilhas é simples: você digita

• Influência não intuitiva entre variáveis

• Dependência causal e temporal

• Todas acima, combinadas com incerteza e um grande número de parâmetros

 As fórmulas são boas em expressar dependências estáticas entre variáveis,

Um modelo de simulação é sempre um modelo executável: sua execução cria uma

Vantagens da modelagem de simulação

4. Em um modelo de simulação, você pode medir valores e rastrear

Aplicações de modelagem de simulação

Nível de abstração Grupos, ciclos de retroalimentação, influências de alto

 Gerenciamento de  Recursos humanos

 Campo de batalha Trânsito (microscópico)

A figura acima mostra várias aplicações de simulação, organizadas pelo nível de

Na parte inferior estão os modelos de nível físico que utilizam representações

 Escolher o nível de abstração certo é crítico para o sucesso do seu projeto de

 No processo de desenvolvimento do modelo, é normal – até mesmo

Os três métodos de modelagem de simulação

Nível de abstração Grupos, ciclos de retroalimentação, influências de

Métodos de modelagem de simulação

Em modelagem de simulação, um método é uma estrutura que usamos para

• Modelagem Baseada em Agentes

influenciados pela propaganda, comunicação e suas interações com agentes e

Preço Caixas Funcionários

Instalando e ativando o AnyLogic

3. Na página AnyLogic License Request, preencha suas informações pessoais e

Você receberá uma confirmação logo depois que enviar o formulário, e

4. Depois que receber a chave de ativação, abra o assistente de ativação do

5. Copie a chave de ativação da mensagem de e-mail que você recebeu e cole-a

Modelagem Baseada em Agentes

• Um desejo de ganhar uma visão mais aprofundada dos sistemas, que as

• Avanços na tecnologia de modelagem, possíveis graças à ciência da

• O rápido crescimento de potência da CPU e da memória. Modelos

um diagrama de estoque e fluxo ou um fluxograma de processo dentro do agente.

Pessoas em diferentes papéis: Equipamentos, veículos:

Coisas abstratas: Organizações:

• Agentes não são autômatos. Agentes não precisam viver em um espaço

• Agentes não são necessariamente pessoas. Qualquer coisa pode ser um

• Um modelo baseado em agentes pode ter muitos ou poucos agentes. O

• Existem modelos baseados em agentes onde os agentes não interagem.

Fase 1. Criando a população de agentes

2. No campo Model name, digite o nome do novo modelo: Market.

Área de trabalho do AnyLogic

• A visão Projects permite acessar os modelos abertos na área de trabalho, e a

• A visão Palette lista os objetos agrupados em paletas. Para adicionar um

• A visão Properties permite visualizar e modificar as propriedades do item

• Para abrir/fechar uma visão, escolha o item correspondente no menu View. Se

5. Vamos abrir a visão Projects para examinar a estrutura do modelo. Você

Navegando pelo modelo na visão Projects

• O AnyLogic usa uma

• Por padrão, um modelo tem um tipo de agente – Main – e um experimento