Genoa Curso Avançado AnyLogic PDF

Treinamento Avançado
em AnyLogic
Esta apresentação faz parte do Treinamento

Avançado oferecido pela Genoa Soluções
Material provided free of charge for the exclusive use for Genoa's AnyLogic online training.
Any copy, reproduction, exploitation, display, alteration of any of its contents for any purpose is strictly prohibited.
Objetivos
• Apresentar e discutir conceitos de modelagem e programação, que ampliam as
possibilidades de simulação do AnyLogic
• Explorar funcionalidades, elementos de modelagem e recursos de terceiros, capacitando o
aluno a construir e utilizar componentes avançados do AnyLogic no seu projeto, visando
aprofundamento de análises e melhorando a qualidade do modelo
• Ampliar as possibilidades de modelagem e simulação dos profissionais participantes, a
partir das tecnologias exclusivas que o AnyLogic oferece
Sumário
• Dia 1
1. POO
2. Java e AnyLogic
3. Desafio 1: Construção programática de schedules
4. Estruturas de dados
5. Desafio 2: Modelagem de uma lanchonete
• Dia 2
1. Desafio 3: Modelagem de supply chain usando dinâmica de sistemas e modelagem de agentes
2. Versionamento de código
3. Desafio 4: Modelagem do processo de manutenção de turbinas eólicas
4. Desafio 5: Resolvendo um problema de Programação Linear
5. Desafio 6: Construção programática de objetos de animação
6. Importação de objetos 3D
• Dia 3
1. Recursos de conectividade
2. Desafio 7: Modelagem de um virador de vagões
3. Desafio 8: Desenvolvimento de blocos bibliotecas personalizados
4. Introdução ao Custom experiment
Agenda - Desafios
• Dia 1
Desafio Tópicos abordados
1. Construção programática de schedules • Vetores de objetos
• Consulta ao banco de dados do
AnyLogic
• Uso de funções
• Consulta a APIs
2. Modelagem de uma lanchonete • Uso de listas
• Construção programática de gráficos
• Experimento Parameters Variation
com replicações
• Conectividade com Excel
Agenda - Desafios
• Dia 2
3. Modelagem de supply chain • Dois paradigmas de simulação:
dinâmica de sistemas e modelagem de
agentes
• Funções
• Comunicação avançada entre agentes
4. Programação de um otimizador • Importação de otimizador externo
• Propriedade de replicações de objetos
de animação
5. Criação de objeto animação via código • Uso de construtores
• Investigação do código Java interno do
AnyLogic
Agenda - Desafios
• Dia 3
6. Modelagem de um virador de vagões • Biblioteca ferroviária
• Listas
• Animação 3D: câmera no trem e
drone
• Custom distribution
7. Criação de um bloco e uma biblioteca • Construção de blocos personalizados
personalizados • Construção de uma Library
• Importação para a Paleta do AnyLogic
Introdução à programação
orientada a objetos
Programação estruturada x orientada a objetos

• No contexto da modelagem de um sistema de software, um paradigma tem a ver com a forma pela
qual o sistema é entendido e construído
• Anteriormente à programação orientada ao objeto, a forma dominante de desenvolvimento dos
sistemas foi o paradigma estruturado, que preconiza que todos os programas possíveis podem ser
reduzidos a apenas três estruturas: sequência, decisão e repetição
• A programação estruturada orienta os programadores para a criação de estruturas simples em seus
programas, usando as sub-rotinas, laços de repetição, condicionais e estruturas em bloco,
praticamente abolindo o GOTO;
• Seu surgimento remonta ao final da década de 1950, com o lançamento das linguagem Algol 58 e
Algol 60
• A programação estruturada foi o paradigma dominante na escrita de software até a programação
orientada a objetos (POO). Enquanto a PE fia-se em estruturas de controle de alto nível (em oposição
ao uso de GOTOs), concepções top-down e refinamento por passos, a POO se baseia no conceito de
objetos que possuem atributos (dados) e métodos (procedimentos)
Programação orientada a objetos

• A orientação a objetos é um paradigma de programação baseado no conceito de "objetos",
que podem conter dados na forma de campos (atributos), e códigos, na forma de
procedimentos (métodos)
• Na POO, programas de computadores são baseado na composição e interação entre os
diversos objetos
• Um objeto é uma abstração de algum fato ou ente do mundo real, com atributos que
representam as suas caraterísticas ou propriedades, e métodos que emulam o seu
comportamento ou atividade
• Todas as propriedades e métodos comuns aos objetos encapsulam-se em classes. Uma
classe é um modelo, um protótipo para criar objetos; no geral, diz-se que cada objeto é uma
instância ou exemplar de uma classe
• Origem: Simula67, criada por Ole Johan Dahl em 1967
• Linguagens: Java, Visual Basic, Delphi (Object Pascal), C++, Python, C#...
Conceitos e Princípios da OO
Conceitos:
• Classe
• Objeto
• Mensagem
Princípios:
• Encapsulamento
• Polimorfismo
• Herança
• Composição
O que é uma classe?

• Uma classe é uma abstração das
características relevantes de um grupo de Representante
coisas do mundo real
• Uma classe é um molde para objetos. Diz-se
que um objeto é uma instância de uma
classe
Cliente
• Na maioria das vezes, um grupo de objetos
do mundo real é muito complexo para que
todas as suas características e
comportamento sejam representados em
uma classe Produto
Objetos
• Uma abstração é uma representação das características e do comportamento relevantes de
um conceito do mundo real para um determinado problema
• Dependendo do contexto, um mesmo objeto do mundo real pode ser representado por
diferentes abstrações:
̶ Carro (para uma transportadora de cargas)
̶ Carro (para uma fábrica de automóveis)
̶ Carro (para um colecionador)
̶ Carro (para uma empresa de kart)
̶ Carro (para um mecânico)
Mensagens
• Para que um objeto realize alguma tarefa, deve haver algum estímulo externo para a ação
• Independentemente da origem do estímulo, quando ele ocorre, diz-se que o objeto em
questão está recebendo uma mensagem
• Uma mensagem é uma requisição enviada de um objeto a outro para que este último
realize alguma ação
Encapsulamento
• O propósito do encapsulamento é o de organizar os dados que sejam relacionados, agrupando-os
(encapsulando-os) em objetos (classes). Este padrão ajuda a manter um programa com centenas
ou milhares de linhas de código mais legível e fácil de trabalhar e manter;
• O encapsulamento de dados leva ao conceito de POO de ocultação de dados, cujo objetivo é
proteger as decisões de projeto e implementação – aspectos que usualmente mais se modificam
num programa – de modificações não previstas;
• Protegendo as informações desta maneira, retira-se a exigência de um conhecimento íntimo do
projeto por parte do usuário, tornando qualquer módulo uma caixa preta, em que só precisamos
saber sobre sua interface: parâmetros e resultados;
• Assim, o usuário não deve se preocupar sobre como é implementada a lógica de determinados
métodos; apenas deve chamá-los (pela interface) e receber os seus resultados;
• O encapsulamento aumenta qualidade do SOO, em termos de:
̶ Legibilidade
̶ Clareza
̶ Reuso
Encapsulamento
• Exemplo: implementação de uma calculadora

̶ Pessoa1: Como funciona a função de somar?
̶ Pessoa2: Você passa dois parâmetros e eu te retorno o resultado
̶ Pessoa1: Mas como é implementado internamente?
̶ Pessoa2: Você não precisa saber disso. ☺
•Exemplo: definir uma rota para transferência de carga

̶ setTransferRoute (String produto, Stock origem, Stock destino, int carga, double
duracao, StockGroupGroup patioOrigem, StockGroupGroup patioDestino)
Herança
• A herança pode ser vista como um nível de abstração acima da encontrada entre
classes e objetos
• Na herança, classes semelhantes são agrupadas em hierarquias:
̶ Cada nível de uma hierarquia pode ser visto como um nível de abstração
̶ Cada classe em um nível da hierarquia herda as características das classes nos
níveis acima
(+)
Figura
Abstração
Figura
Linha
Geométrica
Quadrado Círculo
(-)
Polimorfismo
• Capacidade de objetos derivados de uma mesma base reagirem de forma diferente. Por
exemplo:
̶ A Classe Animal possui operação andar()
̶ A Classe Pessoa derivada de animal, quando andar(), vai andar da sua forma
̶ A Classe Cachorro derivada de animal, quando andar(), vai andar da sua
forma
Refatoração
Coesão e Acomplamento
• Código não coeso: implementação do módulo Calculadora e da operação somar.
Além de somar, envia e-mail para o usuário com o resultado da operação e mostra
mensagem na tela com o resultado
• Problema: mandar e-mail e mostrar mensagem em tela, é desnecessário para o
requisitado
• Buscar o código mais coeso possível (mais simples possível), afinal, o código sendo
coeso, facilita a sua reutilização em novos projetos
Coesão e Acomplamento
• Código não acoplado: um programador implementa o módulo calculadora no
mesmo arquivo da tela de entrada de dados;
• Problema: a calculadora pode ser reutilizada em outro projeto, mas acaba levando
uma tela de entrada de dados desnecessária;
• Buscar sempre o código menos acoplado possível, afinal, um código menos
acoplado facilita a sua reutilização em outros projetos.
Java: histórico e
características
Java: uma breve história

• Em 1991, na Sun Microsystems, foi iniciado o Green Project. Os mentores do projeto eram Patrick
Naughton, Mike Sheridan, e James Gosling. Eles acreditavam que, eventualmente, haveria uma
convergência dos computadores com os equipamentos e eletrodomésticos frequentemente usados
pelas pessoas no seu dia-a-dia;
• No verão de 1992 eles emergiram com o protótipo do “Star Seven” ou *7, um controle remoto com
uma interface gráfica touchscreen. O *7 tinha a habilidade de controlar diversos dispositivos e
aplicações. A linguagem era então denominada Oak, mas as empresas de TV a cabo não entenderam
a ideia como promissora;
• Com o estouro da internet, rapidamente uma grande rede interativa estava disponível. Era este tipo
de rede interativa que a equipe do *7 estava tentando vender para as empresas de TV a cabo. E, da
noite para o dia, não era mais necessário construir a infraestrutura para a rede, ela simplesmente
estava lá.
Java: uma breve história

• Em janeiro de 1995 foi então lançada uma nova versão do Oak que foi rebatizada para Java
• A tecnologia Java tinha sido projetada para se mover por meio das redes de dispositivos
heterogêneos, redes como a internet. Agora aplicações poderiam ser executadas dentro dos
navegadores nos Applets Java e tudo seria disponibilizado pela internet instantaneamente
• A velocidade dos acontecimentos seguintes foi assustadora, o número de usuários cresceu
rapidamente, grandes fornecedores de tecnologia, como a IBM anunciaram suporte para a tecnologia
Java
• Desde seu lançamento, em maio de 1995, a plataforma Java foi adotada mais rapidamente do que
qualquer outra linguagem de programação na história da computação. Em 2004 Java atingiu a marca
de 3 milhões de desenvolvedores em todo mundo
• Java tornou-se popular pelo seu uso na internet e hoje possui seu ambiente de execução presente em
navegadores, mainframes, sistemas operacionais, celulares, palmtops, cartões inteligentes etc
O quanto Java é utilizado hoje?

Java Virtual Machine

Java & AnyLogic
General remarks
• You do not have to learn full OO programming
• You need to understand Java data types, expression and statement syntax
• Please note:
̶ Java is case-sensitive: MyVar is different from myVar!
̶ Spaces are not allowed in names: “My Var” is illegal name!
̶ Each statement has to be finished with “;”: MyVar = 150;
̶ Each function has to have parentheses: time(), add(a)
̶ Dot “.” brings you “inside” the object: agent.event.restart()
̶ Array elements have indexes from 0 to N-1
Data types
• Primitive Types
̶ double – represent real numbers: 1.43, 3.6E18, -14.0
̶ int – represents integer numbers: 12, 16384, -5000
̶ boolean – represents Boolean (true/false) values. Boolean values are only true and false, you
cannot use 1 and 0
• Compound Types – Classes
̶ String – represents textual strings, e.g. “MSFT”, “Hi there!”, etc
̶ ArrayList, LinkedList – collections of objects
̶ Shape3DPolyLine – represents AnyLogic polyline shape
̶ … many others. See AnyLogic and Java Class References
Expressions
Arithmetic operations: Boolean operations:
+ addition and String concatenation && AND
- subtraction || OR
* multiplication ! NOT
/ division
% remainder from integer division
Conditional operator:
condition ? value-if-true : value-if-false
Mind integer division!!! 3/2 = 1, not 1.5
In integer divisions, the fraction part is lost, e.g. 3 / 2 Assignments and shortcuts:
equals 1, and 2 / 3 equals 0 = assignment
Multiplication operators have priority over addition operators += a+=b shortcut for a=a+b
The ‘+‘ operator allows operands of type String
-= a-=b shortcut for a=a-b
Comparison operations: *= a*=b shortcut for a=a*b
< less than /= a/=b shortcut for a=a/b
<= less than or equal ++ a++ shortcut for a=a+1
> greater than -- a-- shortcut for a=a-1
>= greater than or equal
== equal
!= not equal
Left-to-right precedence for operators; parentheses can be used to alter precedence
Some examples
5 % 2 ≡ 1? “Any” + “Logic” ≡ “AnyLogic”

?
5 / 2 ≡ 2? Let x = 14.3, then:

“x = ” + x ≡ “x = 14.3”
?
5.0 / 2 ≡ 5 / 2.0 ≡ 2.5?
“” ≡ empty string
?
(double)5 / 2 ≡ 2.5
?
“” + x ≡ “14.3”
?
a += b; ≡ a = a+b;
?
y=x>0?x:0
a++; ≡ a = a+1;
? ≡ y = max(?0, x )
x == 5 ≡ true if x equals 5,
otherwise false, whereas:
x = 5 ≡ assign 5?to x
?
Calling functions and accessing fields

• Function call
̶ To call a function, type its name followed by parentheses. If necessary, put parameters
separated by commas within the parentheses. Examples:
x = time();
moveTo(getX(), getY() + 100);
traceln(“Population is increasing”);
• Accessing object fields and functions

̶ To access a field or function of a model element (statechart, event, animation shape), use the
element name followed by dot ‘.’ followed by the field/function name. Examples:
rectangle.setFillColor(red);
company.event.restart(10);
Agent populations
• Agent population is a collection.

people [..] Items are indexed from 0 to N-1
Getting the current size of the
population:
people.size( );
Obtaining i-th agent of the population:
people(i);
Obtaining a random agent:
people.random( );
Adding a new agent to the population:
add_people( );
Removing an agent from the population:
remove_people(person);
Built-in functions
• System functions
– time(), date(), pauseSimulation(), inState(…), etc
• Mathematical functions
– sqrt(), sin(), cos(), exp(), log(), round(), etc
• Random distributions
– uniform(), exponential(), bernoulli(), beta(), etc
• Print operators
– traceln() - prints text to Console
– traceToDB() - prints text to the model’s database
• And more…
– See Utilities, Engine, Agent classes in AnyLogic Class Reference
Probability distributions
• Exponential
̶ It has been proven that if events occur at a exponential( rate )
constant rate but are independent, the time
between two subsequent events is distributed
exponentially
̶ Example: phone calls to a call center, client arrivals,
and so on.
• Triangular triangular( min, mode, max )
̶ Is used in the conditions of limited knowledge mode
about the stochastic variable, namely we know the

minimum,
the maximum, and the modal value min max
̶ Example: service time
uniform( min, max )
• Uniform
̶ We only know the minimum and the maximum
values, and do not know if any value in between is
more frequent than another
min max
Decision operator (if … else)

• Checks the condition and executes one section of code (after if) if a condition evaluates to
true, and optionally another code (after else) if it evaluates to false
• Full form (if … else):

if ( condition )
statement if true
else
statement if false
In case “if" or "else" code sections contain

• Short form (if): more than one statement, they should be
if ( inventory < s ) enclosed in braces { … } to become a block,
which is treated as a single statement
{
source.inject(10);
inventory += 10; How would the code look like if we
need to check TWO conditions?
}
for loop
• The loop mostly used to iterate through agent populations and collections
• Population/collection iterator:
for ( agent_type name : population )
{
statements executed for each agent/element
}
for ( Person p : people )

total += p.income;
for ( initialization; continue condition; increment )
{
statements executed for each agent/element
}
• Index-based loop:
for ( int i=0; i<distributor.numberOfTrucks(); i++ )
{
Truck t = add_trucks();
t.setPosition(distributor.getPosition());
}
while loops
• "While" loops are used to repeatedly execute some code while a certain condition
evaluates to true
• While loop int i= 0;
while (excelFile.cellExists(i, 1))
while (continue condition )
{
{
Supplier s = add_suppliers();
statements
s.set_name(excelFile.
}
getCellStringValue(i,1));
i++;
}
double x;
• Do While loop double y;
do
do
{
{
statements
x = uniform(0, 1000);
}
y = uniform(0, 1000);
while (continue condition);
}
while (!citybounds.contains(x,y));
return
• Exits from the current function.
• The return statement has two forms: one that returns a value (e.g. result of
calculations), and one that doesn't. To return a value, simply put the value
after the return keyword.
FUNCTION
Return type: Truck
for (Truck t : fleet)

{
if (t.inState(Truck.AtDistributor))
return t;
}
return null;
Writing comments in Java code

• There are two kinds of comments:
A traditional comment: all the text from the ASCII characters /* to
/* text */ the ASCII characters */ is ignored (as in C and C++)
/*
The class represents AnyLogic 3D animation. It contains the canvas object.
author Daniil Chunosov
version 5.0
*/
public class Animation3DPanel extends javax.swing.JPanel;
// text An end-of-line comment: all the text from the ASCII

characters // to the end of the line is ignored (as in C++).
// Prepare Engine for simulation:

Engine.start(root);
Engine.runFast(); // fast mode – no animation
Traceln
• traceln(Object o): Imprime uma representação textual do objeto especificado
• traceln(Color color, Object o):
Imprime uma representação textual do objeto especificado com a cor do texto definida pelo
argumento color
• traceln(String textFormat, Object... args): O mesmo que traceln (Object o), mas
permite a sintaxe do formato de texto como na função String.format (String, Object
...)
• traceln (Cor da cor, String textFormat, Objeto ... args): análogo ao anterior, mas
com a cor definida pelo argumento color
Traceln
• É possível utilizar o traceln com formatação:
traceln("cenario: %d\nx: %.2f\ny: %.2f\nanimal: %s\n",
cenario, x, y, animal);
• Este tipo de formatação substitui códigos mais longos que concatenam texto com outros
formatos de dados (int, double, float). No exemplo dado, o equivalente sem a formatação
seria:
traceln("cenario: " + cenario);

traceln("x: " + x);
traceln("y: " + y);
traceln("animal: " + animal);
Traceln
Modo de utilização:
• O especificador de formato começa com o símbolo de porcentagem (%) seguido por uma
letra que indica o tipo do dado e o formato desejado.
• O texto deve ser escrito por inteiro dentro de aspas
• Após o texto, deve-se colocar os argumentos, separados por vírgulas, na ordem em que
aparecem no texto
Código: Resultado:
Traceln
Especificador Conversão aplicada

de formato
%d Decimal Integer
%f double ou float
%s String
\t Tabulação
\n Linha
%5.2f Float com 5 números, sendo 2 casas
decimais
%.2f Arredonda para 2 casas decimais
Replications
• As replicações são um recurso muito útil que permite que o usuário crie um número de um mesmo
objeto a partir um único elemento daquele objeto
• Isso faz com que o usuário não tenha que adicionar vários objetos e configurá-los um a um
• Ainda, isso dá a flexibilidade do número destes objetos variarem de simulação à simulação (e em uma
mesma simulação também) de acordo com dados definidos pelo usuário
• Podem ser replicados:
̶ Formas, textos, imagens e objetos 3D (paleta Presentation); todos os controles (paleta Controls); todos
os gráficos (paleta Analisys)
Padrões de nomenclatura
• Padrões do java:
̶ Classes se iniciam com letra maiúscula
̶ Objetos se iniciam com letra minúscula
̶ Funções se iniciam com letra minúscula
• Padrões do AnyLogic - funções iniciadas em:
̶ get: retornam alguma informação do objeto, que pode ser um número, cor, String etc. Ex:
getFillColor()
̶ is: semelhante ao get, mas retornam necessariamente uma informação booleana sobre o objeto.
Ex: isMoving()
̶ set: alteram um parâmetro do objeto. Ex: setCapacity(2)
̶ add: adiciona um objeto novo. Ex: add_population()
̶ remove: Remove um objeto. Ex: remove_population(train)
Cast
• É um mecanismo de conversão explícita, isto é, converter um objeto de um tipo, em outro
• Seu uso mais simples é no truncamento de números reais para inteiros:
Double a = 3.4
int b = (int) a
• No exemplo acima, teremos b = 3

• Outra aplicação muito útil é em super classes e subclasses:
̶ Tomemos como exemplo o objeto chamado “pessoa”. O uso direto do método
pessoa.getCargaHorária() causaria um erro, pois o AnyLogic não sabe que o objeto “pessoa”
é, no devido contexto, um objeto da classe “Professor”. Para corrigir o erro, basta utilizar o cast:
((Professor)pessoa).getCargaHoraria()
• Por outro lado, se o objeto “pessoa” fosse instanciado a partir da classe “Professor”,
poderíamos usar os métodos desta classe sem a necessidade de se usar o cast
Referências: This
• Usado para referenciar o próprio objeto:
double getIdade() {
return this.idade;
}
• Situação prática: um agente do tipo Car

precisa acessar alguma variável que está no
Main. Pode-se criar um parâmetro no agente
Car e acessar a variável
• Dica: sempre que for necessário referenciar
um agente a partir de outro, faça via
parâmetro
Referências: Self
• Faz referência ao bloco/state chart onde está sendo escrito:
Classes
• Todos os agent types do AnyLogic são classes
• Inclusive, qualquer classe criada no AnyLogic pode ser convertida em um agente
Objeto
• Conforme exposto anteriormente, um objeto, no contexto da programação, é uma
abstração de um objeto ou fato real
• Suas características são representadas por atributos. Elas são acessadas por métodos
̶ Exemplo: objeto “carro”:
• características: cor, velocidade máxima, modelo, marca, etc
• Métodos: getColor(), setColor(blue), getSpeed(), setMaxSpeed(100), etc
objeto
Funções
• Executam um trecho de código sempre que é chamada pelo usuário
• Úteis para:
̶ Organizar o ambiente de desenvolvimento, encapsulando partes do código
̶ Executar a mesma rotina várias vezes
Funções
• Podem ou não retornar algum valor
Funções
• Podem demandar argumentos (informações) de entrada:
Sobrecarga de métodos
• O Java permite que criemos vários métodos em uma mesma classe ou agente, com
o mesmo nome. Isto se chama sobrecarga de métodos
• Para isto, basta evitar a ambiguidade, isto é, os argumentos deste método devem
ser diferentes:
• time(): retorna o tempo transcorrido da simulação na unidade de tempo do modelo
• time(HOUR): retorna o tempo transcorrido em horas
Mensagem
• Mensagens são pacotes de dados que são passados entre agentes
• Podem modelar vários objetos do mundo real. Por exemplo, eles podem representar
agentes - peças, produtos, pessoas, caminhões, etc. ou pacotes de dados transmitidos em
uma rede ou comandos e sinais em um sistema de controle
Mensagem
• A mensagem pode ser de qualquer tipo:
̶ int
̶ double
̶ String
̶ List
̶ Etc
Mensagem
• As portas desempenham papel central no
envio de mensagens
• As portas são bidirecionais e podem servir
tanto para entrada quanto para saída de
mensagens
• Para poder acessar as propriedades da
porta referentes às mensagens, deve-se
acessar Tools > Preferences... >
Development e marcar a opção Library
developer mode
Mensagem
Você pode definir uma ação a ser executado quando uma mensagem for enviada/recebida de
duas formas:
1. Nas propriedades da porta por onde

passa a mensagem, escrever um
código com uma ação em On receive:
2. Nas do agente, há
uma propriedade Comunication,
onde, em On message received:, você
pode inserir um código
Mensagem
• Mensagens podem ser enviadas para:
̶ Todos os agentes
̶ Agente aleatório
̶ Agente específico
̶ Lista de agentes que atendam a um critério
Mensagem
• Existem duas funções principais para enviar mensagens: send(...) e deliver(...):
̶ send(...): agenda a entrega da mensagem em um evento separado que será executado após
o evento atual em tempo zero (imediatamente após)
̶ deliver(...): a mensagem é disparada imediatamente, no mesmo evento
Mensagem
• Há ainda a possibilidade de um agente enviar uma mensagem para si próprio, usando a
função receive(...):
Herança
• A título de exemplo, podemos criar no AnyLogic um Agente chamado Pessoa:
Herança
• Um agente “Professor” teria todos os atributos e métodos da classe “Pessoa”, além de seus
próprios atributos e funções
• Para que não seja necessário definir novamente tais atributos, basta fazer com que o agente
“Professor” herde as características do agente “Pessoa”:
Para fazer isso, basta

selecionar o agente
Pessoa no campo
Extends other agent,
na aba Advandeddas
propriedades do
agente Professor.
Herança
• Note que os atributos e métodos definidos
para o agente Pessoa aparecem esmaecidos
no agente Professor e podem ser acessados
• Pode-se, também, criar atributos e métodos
específicos para professores
Herança
• Todos os agentes criados no AnyLogic estendem a classe Agent, isto é, herdam seus
atributos e métodos
• Todas as chamadas built in functions, citadas no slide #9, pertencem à classe Agent
Glossário
Termo/Ação Definição
Agente/Classe Abstração das características relevantes de um grupo de coisas do mundo
real
Objeto Uma instância de uma classe/agente
Construtor Usado para inicializar um novo agente/objeto. Sempre usado com o
comando new
Método No AnyLogic é chamado de function. Usado para realizar ações ou
modificar variáveis de agentes. Pode ou não retornar valores
Parâmetro Comumente usado para guardar características que definem um agente
Variável Comumente usada para guardar informações de um agente que mudam ao
longo do tempo, isto é, temporárias
Cast Conversão de um tipo em outro. Muito usado, por exemplo, para truncar
um número double em um int: int a = (int) 2.0
This Refere-se ao agente onde está sendo chamado
Self Refere-se ao bloco onde está sendo chamado

Dinâmica de Sistemas (DS)

• Amplamente utilizado para modelar sistemas ou processos estratégicos e de longo prazo,
com alto grau de abstração
• Modelagem de processos ou sistemas como estruturas causais fechadas
• Composto por estoques, fluxos e loops de retorno
Dinâmica de Sistemas: estoques

• Acumulações que caracterizam o estado do sistema
• São a memória do sistema
• Atuam como fontes de desequilíbrio, que é corrigido pelos fluxos
• Itens de estoques são homogêneos e indistinguíveis
• Medidos em unidades de quantidade:
• Pessoas
• Níveis de estoque
• Dinheiro
Dinâmica de Sistemas: fluxos

• Buscam minimizar os desequilíbrios entre estoques
• Associados à noção de tempo - medidos como taxas:
̶ Clientes/ano
̶ Dólares/dia
̶ Unidades/hora
Dinâmica de Sistemas: loops de retorno

• Representação da causalidade circular
• Podem ser loops de balanceamento ou de reforço:
̶ Atuam simultaneamente no sistema
̶ Suas “forças” variam ao longo do tempo
Dinâmica de Sistemas: funções

• O AnyLogic apresenta diversas funções que enriquecem a
modelagem de dinâmica de sistemas
• Estas funções podem ser chamadas em fórmulas de variáveis
de dinâmica de sistemas (fluxos, variáveis dinâmicas, etc)

Nome Ação
delay(input, delayTime) Retorna os dados de entrada com um atraso igual ao delayTime.
Apresentam mesmo resultado se o delayTime é constante.
delayInformation(input, delayTime)
delayMaterial(input, delayTime)
delay1(input, delayTime) Retorna os dados de entrada com um atraso exponencial de
ordens 1 e 3 do input.
delay3(input, delayTime)
forecast(input, averageTime, horizon) Retorna uma previsão do valor que o input assumirá no
horizonte horizon de tempo médio averageTime.
npv(stream, discountRate, initialValue, factor, retorna o valor presente líquido do stream calculado usando o
timeStep) discountRate. O valor inicial é determinado por
initialValue (geralmente 0) e o valor é relatado após a
npve(stream, discountRate, initialValue, factor,
timeStep)
multiplicação por factor (geralmente 1).
npve assume que o stream é avaliado no final do período.
pulse(startTime, pulseWidth) Retorna 1, começando em startTime e durando pelo intervalo
pulseWidth. 0 é retornado caso contrário.

Nome Ação
pulseTrain(startTime, pulseWidth, Retorna 1, começando em startTime e durando no intervalo
timeBetweenPulses, double endTime) pulseWidth e, em seguida, repete esse padrão com intervalo
timeBetweenPulses até endTime; retornando 0 caso contrário.
Se o valor de timeBetweenPulsesis for menor que
pulseWidth, então 1 será retornado entre startTimeand e
endTime.
ramp(slope, startTime, endTime) Retorna 0 até o startTime e então se inclina de acordo com o
slope até o endTime e, então, permanece constante.
smooth(input, delayTime) Retorna uma suavização exponencial do input de ordem 1 e 3,
respectivamente. Comportamento semelhante a delay1 e
smooth3(input, delayTime) delay3.
step(eight, stepTime) Retorna 0 até stepTime e depois retorna height.
trend(input, averageTime, initialTrend) retorna a taxa de crescimento fracionária média (negativa

para declínio) do input.
Desafio 1:
Construção programática
de schedules
Motivação
• Schedules permitem que valores mudem ao longo do tempo, de maneira periódica:
̶ Chegada de carros
̶ Turnos de trabalhadores
̶ Horários de manutenção
• Podem ser criados manualmente, arrastando-se o elemento “Schedule” para o editor
gráfico
Motivação
• Um schedule pode ser usado para organizar turnos de trabalho, e pode conter quantos
turnos quanto necessários
Motivação
• Para situações/modelos pequenos ou que não mudam ao longo do tempo, esta abordagem
funciona bem
• Por outro lado, imagine um dos seguintes cenários:
̶ Temos que simular um número muito elevado de turnos
̶ Estes turnos mudam semanal/mensalmente
• Neste caso, digitar manualmente os turnos consumiria muito tempo e não seria producente
• A alternativa é criar o schedule e os turnos programaticamente, lendo as informações de
uma base de dados
• Desta forma, sempre que houver alterações, o modelo já estará atualizado
Schedule programático – Fase 0

• O modelo recebido é um fluxo simples, composto por um três blocos: source, service e sink,
além de um resource pool e um schedule

• O bloco service está associado ao recurso operadores que, por sua vez, tem sua capacidade
definida pelo bloco schedule:
Schedule programático – Fase 1 – Passo 1

• Nesta etapa, vamos criar um schedule e adicionar turnos programaticamente
1. Copie o fluxo de processos e o resource pool da fase 0:
A. Selecione os elementos no editor gráfico
B. Cole com o botão direito do mouse
2. Renomeie o ResourcePool como operadores_f1

1. Vincule o resource pooldo bloco service1 ao bloco
operadores_f1
2. Da paleta de agentes, crie uma função e a nomeie
createSchedule_f1(). Esta função irá criar o scheduledo
resource pool da fase 1
3. Nas propriedades, marque a opção Returns value, e, no
campo Type, escreva Schedule<Integer>
4. Nas propriedades do ResourcePool dos operadores, defina o
Capacity schedule que foi criada createSchedule_f1().
• No corpo desta função iremos criar e inicializar o schedule


• Vamos criar um schedule com as seguintes características:
̶ Inicia-se aos domingos
̶ Inicialmente vazio
̶ Armazena números inteiros (número de operadores de cada turno)
̶ Período de 7 dias
̶ Mesmos turnos do schedule da fase 0

• Assim, iniciamos a função createSchedule_f1() com o seguinte código:
Schedule mySchedule = new Schedule<Integer>(); //schedule vazio

mySchedule.setOwner(this); //ambiente onde está sendo criado
mySchedule.setCalendarType(true); //usa calendário
mySchedule.setFirstDayOfWeek(SUNDAY); //primeiro dia da semana
mySchedule.setPeriod(7); //período
• Obs.: ao pesquisar por “Schedule API” no help do AnyLogic, há explicações para as funções
usadas e um modelo exemplo

• Agora devemos adicionar os turnos (intervalos) do schedule
• Há várias formas de se fazer isso:

• O primeiro intervalo do schedule possui dois operadores e uma hora de duração:
//adicionando turnos
mySchedule.addInterval(0, //hora inicial
0, //minuto inicial
0, //segundo inicial
1, //hora final
0, //minuto final
0, //segundo final
2,//número operadores
new int[] {1, 2, 3, 4, 5, 6, 7}); //dias ativas
• Analogamente, adicione os outros dois intervalos, construindo um schedule idêntico àquele

da fase 0

• Finalmente, deve-se inicializar o schedule e realizar o comando return da função:
mySchedule.initialize();
return mySchedule;

• Da paleta de Analysis, crie um Time Plot para acompanhar o número de operadores da fase
1, análogo ao da fase 0:
Schedule programático – Fase 1 – Rodando o modelo

• Execute o modelo
• Observe que as fases 0 e 1 exibem o mesmo comportamento:

• Nesta etapa, iremos criar uma planilha contendo os turnos de trabalho no database do
AnyLogic:
• Desta forma, podemos inseri-los de maneira iterativa no schedule e de fato tirar proveito da
construção programática

• Copie o fluxo de processos e o resource pool da fase 2:
Para isso, siga os passos de maneira análoga ao que foi feito na Fase 1 – Passo 1

1. Vincule o resource pool do bloco
service2 ao bloco operadores_f2
2. Crie uma cópia da função
createSchedule_f1(), obtendo
a função createSchedule_f2()
3. Na função recém criada, apague o
trecho de código referente à adição
de intervalos (turnos):
̶ As três chamadas da função
addIntervals(...)
̶ Esta parte do código dará lugar à
leitura do database
Trecho a ser removido

• Atualize o campo “Capacity schedule” do bloco “operadores_f2”, vinculando-o à função
createSchedule_f2():

• Para iterar sobre uma tabela do database, devemos usar
o auxiliar de queries do AnyLogic, que fica localizado no
menu superior:
• Este auxiliar gera um código base, que deve ser usado

como guia para o desenvolvimento do nosso próprio
código

• Com base no código fornecido pelo auxiliar de queries, podemos realizar a leitura dos turnos
na função createSchedule_f2():
for (Tuple row : rows) {
mySchedule.addInterval(row.get( turnos.hora_inicio ),//hora inicial
0,
0,
row.get( turnos.hora_fim ),//hora final
0,
0,
row.get( turnos.valor ),//número operadores
new int[] {1, 2, 3, 4, 5, 6, 7});
}
• Note que, nesta etapa, o aumento no número de turnos não se traduz em um aumento no
esforço empregado na modelagem, justificando o uso do schedule via código

• Finalmente, crie um último Time Plot:
Schedule programático – Fase 2 – Executando o modelo

• Ao executar o modelo, observamos que as três fases exibem o mesmo comportamento,
conforme esperado:
Estruturas de dados
Arrays
• Em um código, podemos declarar algumas variáveis e usá-las:
̶ cargaPilha1 = 3000;
• Esta prática pode ser ruim quando o número de variáveis muda: caso tenhamos mais uma
pilha, no exemplo acima, teríamos que criar mais uma variável:
Arrays
• Para resolver esse problema, podemos usar arrays
• Existem duas formas de inicialização: já com o conteúdo ou vazio:
int[] pilhas = {3000, 5000, 10000, 7000};
int[] pilhas = new int[4];
pilhas[0] = 3000;
pilhas[1] = 5000;
pilhas[2] = 10000;
pilhas[3] = 7000;
Arrays
• A principal desvantagem no uso de arrays é que seu tamanho não pode ser alterado após
sua inicialização
Tipo dos dados armazenados no array
int[] pilhas = new int[4];
tamanho do array
Coleções
• São estruturas mais flexíveis que arrays para armazenamento de dados
• Representam grupos de objetos, chamados elementos
• Podem ou não permitir valores duplicados
• Podem ou não ser ordenadas ou garantir ordenação
• São utilizadas para armazenar, recuperar e manipular dados agregados
• Tipicamente, representam itens que formam um grupo “natural”, como:
̶ Ordens de serviço
̶ Caminhões em fila
̶ Linhas ferroviárias disponíveis
̶ Cardápio
̶ Agenda
• Existem três categorias de coleções:
̶ Listas (ArrayList e LinkedList)
̶ Conjuntos (LinkedHashSet e TreeSet)
̶ Mapas (TreeMap e LinkedHashMap)
• As classes entre parênteses são as mais utilizadas, mas não as únicas disponíveis
Listas
• Permitem inserção de elementos repetidos e nulos
• Principais classes: ArrayList e LinkedList
• ArrayList: muito semelhante com arrays – internamente, os elementos são armazenados como
arrays. Aumenta seu tamanho dinamicamente em 50%
• LinkedList: implementação computacional diferente da ArrayList – lista ligada. Mais eficiente para
adicionar e remover elementos
• Permitem adição e remoção dinâmica de elementos, por meio das funções add() e remove():
̶ ArrayList<int> pilhas = new ArrayList();
̶ pilhas.add(3000);
̶ pilhas.add(7000);
• Para acessar algum elemento da lista, usa-se a função get(n), em que n é o n-ésimo termo da lista:
̶ pilhas.get(0) = 3000;
̶ pilhas.get(1) = 7000;
Conjuntos (Sets)
• Não permitem inserção de elementos repetidos. Assim, dispensa uso da função
contains() antes da inserção
• Não permitem acesso por índice
• Principais classes: LinkedHashSet e TreeSet
• LinkedHashSet: garante ordenação, isto é, mantém os elementos armazenados na ordem
de inserção
• TreeSet: elementos armazenados de maneira “natural” – ordem crescente ou alfabética
Mapas
• Diferentemente de listas e conjuntos, demanda inserção de elementos no formato <chave ,
valor> por meio da função put(key , value)
• Não permitem chaves duplicadas. Ao inserir mais de uma vez a mesma chave, o valor
associado é sobreposto
Chave Valor
“A” 3000
“B” 10
“C” 500
Mapas
• Exemplo de uso: um cardápio com o nome dos pratos e seus preços:
̶ cardapio.put(“Lanche 1”, 20.00);
̶ cardapio.put(“Refrigerante”, 4.00);
̶ cardapio.put(“Batata”, 8.00);
• A busca de elementos em um mapa é feita usando-se a chave:

̶ double precoBatata = cardapio.get(“Batata”) => precoBatata = 8.00;
• A remoção de um elemento é feita utilizando-se a chave:

̶ cardapio.remove(“Suco de Goiaba”);
• Para saber se a lista contém uma certa chave:

̶ boolean temSalada = cardapio.contains(“Salada”);
Mapas
• Principais classes: TreeMap e LinkedHashMap
• TreeMap: não garante ordenação, ordenando chaves de maneira “natural”
• LinkedHashMap: mantém ordenação, isto é, mantém os elementos armazenados na ordem
de inserção
Performance
Operação ArrayList LinkedList LinkedHashSet TreeSet TreeMap LinkedHashMap
Obter Constante Constante Constante Constante Constante Constante
tamanho
Adicionar Constante Constante Constante Log Log Constante
elemento
Remover Linear Linear Constante Log Log Constante
item
Remover Linear Linear – – – –
por índice
Acessar Constante Linear – – – –
por índice
Descobrir Linear Linear Constante Log Log Constante
se contêm
Listas Conjuntos Mapas

Desafio 2:
Modelo de uma
lanchonete
Motivação
• Construiremos uma lanchonete, em que clientes chegam, fazem e retiram seus pedidos
• O objetivo desta atividade é usar este modelo como base para utilizar os seguintes
conceitos:
̶ Funções
̶ Listas
̶ Experimento parameters variation com replicações
• Iremos utilizar também a paleta de conectividade:
̶ Excel
Lanchonete
Este desafio é divido em duas fases:
1. Fase 1 – Construção do modelo
2. Fase 2 – Parameters Variation
Lanchonete – Fase 1 – Passo 1

1. Vá em File > New > Model
2. Digite Lanchonete em Model name, selecione minutes como Model time units e, por fim,
clique em Finish

Primeiramente, criaremos duas novas classes (ou agentes), Cliente e Pedido, que irão entrar
no sistema, sendo:
Cliente Pedido

Crie os clientes:
1. Vá para a aba Projects
2. Clique com o botão direito > New > Agent Type
3. Selecione Agent type only
4. Dê o nome “Cliente”
5. Clique em Finish

Analogamente, crie o agente “Pedido” com os seguintes parâmetros:
Agent Pedido:
lanche: String
vaiBatata: boolean
vaiRefri: boolean
cliente: Cliente

Todo cliente possui um pedido. Portanto, volte ao agente Cliente e insira um parâmetro
chamado pedido, do tipo Pedido.
(1) Arraste um novo

Nomeie de pedido e escolha
Type: Pedido
(2) Adicione a variável t0, do tipo double. Ela

nos auxiliará na medição do tempo em fila

Utilizaremos os blocos da biblioteca Process Modeling para criar o processo no modelo.
Nomeie os blocos como se segue:
Clique e arraste os blocos

da paleta para a Main

Crie os parâmetros do sistema. Eles definirão as características do nosso modelo de
Lanchonete.
cenario (int)
taxaChegada (double): 1.0
numeroAnotadores (int): 2
numeroCozinheiros (int): 3
tempoFazerPedido (double): triangular(1.0, 3.0, 2.0)
esperaDesistencia (double): 5.0

Adicione os recursos, nomeando-os anotadoresPedido e cozinheiros.
Clique e arraste dois blocos

do tipo ResourcePool

1. Associe a capacidade de cada recurso com o parâmetros que criamos anteriormente,
numeroAnotadores e numeroCozinheiros.
2. Mude o Resource type para Static

A partir daqui, vamos atualizar os campos dos blocos de processo
(1) Selecione Rate e

Arrival rate: taxaChegada
per minute
(2) New agent: Cliente


Ainda no bloco chegadaClientes, vamos gerar o pedido que acompanhará o cliente. Assim,
escreva o código em Actions > On exit:
// Gera um pedido
String lanche = randomTrue(0.5) ? "lanche1" : "lanche2";
boolean vaiBatata = randomTrue(0.5);
boolean vaiRefri = randomTrue(0.5);
agent.pedido = new Pedido(lanche, vaiBatata, vaiRefri, agent);
agent.t0 = time();
(4) Gere um novo objeto do tipo

Pedido, definindo o valor de seus
parâmetros

(3) Em Advanced, marque
(1) No bloco anotaPedido, aloque um recurso Queue: exit on timeout.
anotadoresPedido Defina o tempo de espera máximo:
esperaDesistencia, em minutes
(2) Marque Maximum

queue capacity
e coloque em Delay time:
tempoFazerPedido(),
em minutes
Clique no sinal de igual

para torná-lo uma seta
Digite em New agent (copy):
original.pedido
Original type: Cliente

Copy type: Pedido
No bloco preparoPedido, aloque

o recurso cozinheiros
Mude o Agent type para Pedido


No bloco Match devemos definir quando o cliente poderá sair. Isso ocorrerá quando o pedido,
correspondente ao cliente que o fez, estiver pronto. Dessa forma, escreva em
Match condition: agent2.cliente == agent1 agent2 = Pedido
agent1 = Cliente
Marque as duas opções

Maximum capacity

No bloco preparoPedido, o delay time dependerá do pedido, pois cada item requer um tempo
de preparo diferente. Assim, para calcular o tempo total de preparo do pedido, criaremos:
• uma lista que associa cada item a um tempo de preparo (LinkedHashMap)
• uma função que, quando chamada, recebe os parâmetros do pedido, acessa a lista de
tempos de preparo e soma os tempos de cada item

Crie a lista de tempos de preparo, adicionando uma Collection no Main:
(2) Dê o nome temposPreparo
(1) Clique e arraste uma

na Main
(3) Selecione o tipo LinkedHashMap, no qual:

• Chave (Key): String
• Valor (Value): double

Vá até o campo Main > Properties > Agent actions > On startup:
Adicione itens à lista temposPreparo, na qual para cada item (chave -> String) associa-se um
determinado tempo (valor -> double):
• Lanche 1: 2.0 minutos

• Lanche 2: 3.0 minutos Utilize o comando put para
• Batata: 1.0 minuto adicionar novos itens à
LinkedHashMap
• Refrigerante: 0.5 minutos
temposPreparo.put("lanche1" , 2.0);
temposPreparo.put("lanche2" , 3.0);
temposPreparo.put("batata" , 1.0);
temposPreparo.put("refrigerante" , 0.5);

Crie a função para calcular o tempo total de preparo
(2) Dê o nome calculaTempoPreparo
(1) Clique e arraste uma
no Main
(3) Defina para retornar

um valor do tipo double
(4) Defina os argumentos:

lanche: String
vaiBatata: boolean
vaiRefri: boolean

Nessa função vamos calcular a duração do
tempo total de preparo.
Para isso, vamos acessar chaves -> valores da
coleção temposPreparo (LinkedHashMap) que Utilize o comando get para
acessar o valor das chaves
criamos anteriormente. da LinkedHashMap
double duracao = 0;
duracao += triangularAV(temposPreparo.get(lanche), 0.05);
if(vaiBatata)
duracao += triangularAV(temposPreparo.get("batata"),
0.05);
if(vaiRefri)
duracao +=
triangularAV(temposPreparo.get("refrigerante"), 0.05);
}
return duracao;

Ao acessar valores em uma LinkedHashMap, é recomendável utilizar o comando try para o
tratamento de erros.
double duracao = 0;
Atualize a função com o comando
try{ try e insira uma mensagem para
duracao += triangularAV(temposPreparo.get(lanche), 0.05); o caso de ocorrência de erro
if(vaiBatata)
duracao += triangularAV(temposPreparo.get("batata"), 0.05);
if(vaiRefri)
duracao += triangularAV(temposPreparo.get("refrigerante"), 0.05);
}
catch(Exception e){
traceln("Item não cadastrado no cardápio");
}
return duracao;

Volte ao bloco preparoPedido e atualize o campo Delay time, utilizando a função criada
Delay time: calculaTempoPreparo(agent.lanche,

agent.vaiBatata,
agent.vaiRefri)
Selecione: minutes
Lanchonete – Fase 1 - Executando o modelo

O processo está pronto. Simule!
Lanchonete – Fase 2
Nesta etapa, utilizaremos o recurso Parameters
Variation para simular vários cenários e obter
resultados estatísticos.
Existem inúmeras maneiras de configurá-los no
AnyLogic:
Interface do ParametersVariation
• Interface do Parameters Variation
• If, else if, switch...
• Json
• Banco de dados
Em nosso exercício utilizaremos o switch
Banco de dados
Nesta fase do exercício, iremos:
• Configurar diferentes cenários utilizando o comando switch.
• Utilizar replicações no experimento
• Obter resultados estatísticos dos cenários simulados
• Passar os resultados para um arquivo excel

Comece criando o novo Experiment. Vá em Projects > botão direito do mouse > New >
Experiment
Selecione a opção:
Parameter Variation

Nas configurações do PV, iremos variar
somente o cenario
Baseado no número do cenário, iremos setar
diferentes valores para os demais parâmetros
na inicialização do modelo.
(1) Mude o tipo para

Range e coloque os
valores Min: 0, Max:
3, Step:1

Continuando a configuração do experimento, faça as alterações indicadas:
(3) Escolha Random seed
(unique simulation runs)
(4) Marque a opção

Use replications
(2) Altere o Stop time para 10080.


• No campo On Startup do Main, utilize o comando switch para
configurar os parâmetros em cada cenário
• Em nosso exemplo, criaremos 4 cenários, variando o número de
anotadores, cozinheiros e tempo de espera até a desistência
switch(cenario) {
case 0:
numeroAnotadores = 1;
numeroCozinheiros = 3;
break;
case 1:
esperaDesistencia = 10;
break;
case 2:
Para finalizar, é importante
break; usar o comando set_capacity
case 3: nos recursos para atualizá-los
break;
}
anotadoresPedido.set_capacity(numeroAnotadores);
cozinheiros.set_capacity(numeroCozinheiros);
Lanchonete – Fase 2 – Executando o modelo (PARTE I)

Se rodarmos o experimento, podemos ver os parâmetros variando automaticamente e as 10
replicações sendo rodadas
Lanchonete – Fase 2 – Parameters Variation

Com relação aos resultados estatísticos das simulações, queremos para cada cenário:
• Tempo médio em fila para fazer o pedido
• Tempo médio em fila para retirar o pedido
Obs.: Lembrar que cada cenário está sendo rodado 10 vezes.

Lanchonete – Fase 2 – Parameters Variation

Existem inúmeras maneiras de se fazer isso:
• Variáveis
• Listas
• Bloco Statistics
• Classes
• Banco de dados
• traceln
• Outros?
A coleta de estatísticas do modelo será feita por meio do bloco Statistics da biblioteca
Analysis.
Statistics Principais funções

• Utilizado para se coletar estatísticas (mínimo,
média, máximo, desvio padrão etc.) de uma
série de dados
• Um bloco de estatística pode armazenar
estatísticas discretas ou contínuas:

Arraste dois elementos do tipo Statistics (paleta Analysis) e defina-os da seguinte forma:
Statistics:
statsEsperaFazerPedido
statsEsperaRetirarPedido
• Discrete (samples have no duration

in time)
• Do not update data automatically
Atualize a statsEsperaFazerPedido no
bloco anotaPedido, conforme indicado
Da mesma forma, atualize a

statsEsperaRetirarPedido no
bloco liberaClientes.

Os resultados estatísticos devem ser salvos a cada
replicação rodada.
Assim, utilizaremos uma LinkedHashMap, onde:
• Chave: Integer
• Valor: Bloco Statistics
Comece arrastando duas Collections na

área do ParametersVariation. Nomeie-as:
mediasFazerPedido
mediasRetirarPedido

Configure as collections criadas: StatisticsDiscrete
é o tipo do bloco

Guardaremos também o valor dos parâmetros em cada cenário.
Para isso, utilizaremos uma LinkedHashMap, onde:
Chave: Integer
Valor: Array
Crie uma nova

collection
parametrosCenarios
e configure-a como
mostrado

A média deve ser guardada ao final de cada replicação. Assim, vá em ParametersVariation >
Java Actions > After simulation run:
if(!mediasFazerPedido.containsKey(root.cenario)) {
Utilize o comando put para
mediasFazerPedido.put(root.cenario , new StatisticsDiscrete());
inserir um novo cenário na
mediasRetirarPedido.put(root.cenario , new StatisticsDiscrete());
LinkedHashMap e new para
criar um novo bloco
double[] valores = {root.numeroAnotadores,
Statistics
root.numeroCozinheiros,
root.esperaDesistencia};
parametrosCenarios.put(root.cenario , valores);
}

Ainda no campo After simulation run:
mediasFazerPedido.get(root.cenario).add(root.statsTempoFazerPedido.mean());
mediasRetirarPedido.get(root.cenario).add(root.statsTempoRetirarPedido.mean());
Utilize o comando get para

acessar as Statistics do cenário e
depois add para adicionar um
novo valor
Lanchonete – Fase 2 – Executando o modelo (PARTE II)

Podemos rodar o experimento e verificar os resultados.

Passaremos agora os resultados para um arquivo Excel.
(1) Crie um arquivo .xlsx na

mesma pasta do modelo
(3) Renomeie seu

bloco de output
(2) Arraste o arquivo criado para a
área do ParametersVariation. O
AnyLogic gera automaticamente
um bloco de conexão com o Excel

Os resultados devem ser passados para o Excel somente ao final do experimento, depois que
todas as iterações e replicações foram rodadas. Portanto, vá para o campo
ParametersVariation > Java actions > After experiment:
output.setCellValue("Cenário", 1, 1, 1);
output.setCellValue("# Anotadores", 1, 1, 2);
output.setCellValue("# Cozinheiros", 1, 1, 3);
output.setCellValue("Tempo desistência (min)", 1, 1, 4);
output.setCellValue("Tempo fazer pedido (min)", 1, 1, 5);
output.setCellValue("Tempo retirar pedido (min)", 1, 1, 6);
O comando setCellValue possui inúmeros métodos.

Utilizaremos o seguinte:
setCellValue(value, sheetIndex, rowIndex, columnIndex)

Ainda no campo After experiment:
int i = 2;
for(Integer c : mediasFazerPedido.keySet()) {
output.setCellValue(c, 1, i, 1);
output.setCellValue(parametrosCenarios.get(c)[0], 1, i, 2);
output.setCellValue(mediasFazerPedido.get(c).mean(), 1, i, 5);
output.setCellValue(mediasRetirarPedido.get(c).mean(), 1, i, 6);
i++;
}
Valores guardados em um Array podem

ser acessados por
array[Posição do elemento].
Statistics permitem obter a média das
observações pelo comando mean()
Lanchonete – Fase 2 – Executando o experimento

Rode o PV e veja os resultados no Excel! Lembre-se de fechar o arquivo Excel
antes de rodar o experimento.

A escrita no Excel, por padrão, não apaga o conteúdo existente nas planilhas. Assim,
adicionalmente, você pode limpar as células antes de passar os resultados:
int ultimaLinha = output.getLastRowNum(1);

if(ultimaLinha != 1) {
int ultimaColuna = output.getLastCellNum(1, ultimaLinha);
for(int i = 1; i <= ultimaLinha; i++) {
for(int j = 1; j <= ultimaColuna; j++) {
output.clearCell(1, i, j);
}
}
}
O método clearCell limpa o conteúdo

de determinada célula.

• Como nenhuma configuração precisa ser ajustada no momento de execução do modelo,
apertar o “play” antes da execução do experimento é desnecessário. Por isso, insira o código
run() no campo “Initial experiment setup”. Isso faz com que o parameters variation tenha
início imediatamente após ser lançado
• Além disso, como não temos um dashboard de saída no experimento, mas apenas no Excel,
podemos fechar a janela do experimento automaticamente. Para isso, insira o código
getExperimentHost().close() no campo “After experiment”
Desafio 3: Modelagem de
supply chain usando
dinâmica de sistemas e
modelagem de agentes
Motivação
• Neste exercício, construiremos um modelo difusão de um produto no mercado associada às
decisões da cadeia de suprimentos desse produto
• A modelagem mescla abordagem de Dinâmica de Sistemas e baseada em Agentes (AB –
Agent Based)
̶ A abordagem de DS é útil para modelar sistemas de uma perspectiva mais macroscópica, por
exemplo para observar a dinâmica de uma população diante da difusão de produto, doença etc.
̶ A abordagem baseada em agentes possibilita a implementação de decisões com base no estado
atual de um agente ou de características dele
Motivação
• Este exercício está dividido em duas fases:
̶ Fase 1: modelagem de DS: difusão do produto e criação de demanda
̶ Fase 2: modelagem AB: fabricação dos produtos e atendimento da demanda
Supply Chain DS e AB – Fase 1 – Passo 1

1. Crie o modelo e nomeie-o Supply Chain DS e AB e mude a unidade de tempo do modelo
para dias
2. Da paleta de System Dynamics, arraste para o editor gráfico três stocks, nomeando-os
UsuariosEmPotencial (initial value = 100.000), Demanda e Usuarios

1. Crie um fluxo indo do stock UsuariosEmPotencial para o stock Demanda, nomeando-o
TaxaAdocao
2. Crie um fluxo indo do stock Usuarios para o stock Demanda e o nomeie ReusoProduto

1. Crie, no editor, 4 parâmetros, nomeando-os EfetivProp, TaxaContato, Fracao e
VidaUtilProduto
2. Preencha as propriedades dos parâmetros como indicado
Type: Rate
Type: Rate Unit: per day Type: Rate
Unit: per day Default value: 10 Unit: per day
Default value: 0.0011 Default value: 0.001
Type: Time
Unit: days
Default value: 60

1. Crie links entre os parâmetros EfetivProp, TaxaContato, Fracao e o fluxo TaxaAdocao
2. Crie um link entre o parâmetro VidaUtilProduto e o fluxo ReusoProduto
1 2

3. Crie links indo dos stock UsuariosEmPotencial e Usuarios para o fluxo TaxaAdocao
4. Crie um link indo do stock Usuarios para o fluxo ReusoProduto
1
3

Devemos, agora, inserir as expressões que definirão
as taxas dos fluxos:
1. Nas propriedades do fluxo TaxaAdocao, insira:
UsuariosEmPotencial * EfetivProp
+ Fracao * Usuarios * TaxaContato * UsuariosEmPotencial / (
UsuariosEmPotencial + Usuarios )
2. Nas propriedades do fluxo ReusoProduto, insira:

Usuarios / VidaUtilProduto

Neste modelo, haverá um “fluxo” indo de Demanda para Usuarios, mas isso se dará
através das ações dos agentes que criaremos posteriormente, que, ao atenderam a
demanda, criarão usuários. Este “fluxo” será provocado por uma função, chamada de
atendDemanda
1. Da paleta de Agentes, crie uma função, nomeando-a atendDemanda

2. Nas propriedades, crie um argumento chamado
quant, que será do tipo int
3. Insira o seguinte código:
Demanda -= quant;
Usuarios += quant;

Criaremos agora o segundo agente do nosso modelo, a Fábrica:
1. Da paleta de agentes, arraste para o editor um agente e escolha a opções A single agent > I
want to create a new agent type > clique em Next
2. nomeie-o Fabrica, clique em Next, deixe-o sem animação e clique em Finish

1. No editor do agente Fabrica, arraste o ícone Warehouse da paleta Pictures
2. Nas propriedades, marque a opção Icon e, em On click, na seção Advanced, insira o código
return true, para que seja possível navegar até este agente a partir do Main, durante a
execução do modelo

1. Da paleta de agentes, arraste um Port, posicione-o na borda esquerda da imagem e o
nomeie portaVendedor

1. Ainda no editor do agente Fabrica, crie
uma variável e a nomeie
taxaProducaoReal
2. Da paleta de System Dynamics, crie um
stock, nomeie-o invent
A. Nas propriedades, insira um Initial value
de 200 e marque a opção Custom em
Equation mode
B. Com o campo d(invent)/dt agora
habilitado, insira taxaProducaoReal nele
3. Por fim, devemos adicionar um link
entre a variável taxaProducaoReal e o
stock invent, da paleta de System
Dynamics

Agora, começaremos a criar os elementos da abordagem de agentes do modelo
1. Da paleta de agentes, arraste para o editor um agente e escolha a opções A single agent > I
want to create a new agent type > clique em Next
2. nomeie-o Vendedor, clique em Next, deixe-o sem animação e clique em Finish

1. No editor do agente Vendedor, arraste a imagem store da paleta Pictures
2. Importe o arquivo IconeVendedor.png disponibilizado
3. Nas propriedades, marque a opção Icon e, em On click, na seção Advanced, insira o código
return true
1. Da paleta de agentes, arraste um Port,

posicione-o na borda direita da imagem
e o nomeie portaFabrica
2. Da paleta de System Dynamics, arraste
uma variável dinâmica e, posicione-a na
borda esquerda da imagem e a nomeie
Demanda
3. Nas propriedades da variável dinâmica

Demanda, marque a opção
Dependent
4. Marque a opção Visible on upper
agent

1. De volta ao editor do Vendedor, crie uma variável e a nomeie invent
2. Nas propriedades, mude o Type para int e insira 100 no campo Initial value

1. Volte ao editor do Main e, da paleta de Agentes, crie um Connector indo do stock
Demanda para a variável dinâmica do agente Vendedor
2. Crie um conector ligando as portas dos dois agentes
Supply Chain DS e AB – Classes
• Criaremos os pedidos, que transitarão entre

a fábrica e o vendedor
• Estes objetos serão representados pela
classe Pedido

Clique em File > New > Java Class e nomeie a classe como Pedido:

3. Adicione o atributo quantidade, do tipo int e com acesso privado
4. Desmarque as opções Create constructor e Create toString() function e clique em Finish

1. Abaixo do código
private int quantidade;
insira o seguinte:
Pedido( int quant ) { Construtor da classe Pedido
this.quantidade = quant;
}
public int getQuant() { Método que permite acessar

o atributo quantidade de
return this.quantidade;
um objeto do tipo Pedido
}

Para editarmos as propriedades do Port, precisamos habilitar uma opção de desenvolvedor nas
preferências. Para isso:
1. Clique em Tools > Preferences...

2. Na aba Development, marque a opção
Library developer mode
1. No editor do agente Fabrica, crie, a

partir da paleta de Agentes, uma
Collection e a nomeie pedidos
2. Nas propriedades, mude a Collection
class para LinkedList e o Element class
para Pedido
3. Selecione a porta do ícone e edite as

seguintes propriedades
̶ Na seção Message handling actions,
insira o código pedidos.add(msg);
̶ Na seção Advanced, mude os campos In
message type e Out message type para
Pedido

1. Ainda no agente Fabrica, crie um
parâmetro e, nomeie-o
TaxaProducaoNormal e, nas
propriedades:
̶ Default value: triangular( 1000 , 1500 ,
2000 )
̶ Marque a opção Dynamic na seção
Advanced

1. Da paleta de Agentes, arraste um Dynamic Event
para o editor do agente Fabrica e o nomeie
RealizaEntrega
2. Nas propriedades:
̶ Na seção Arguments, adicione um argumento
pedido, do tipo Entrega
̶ Na seção Actions, insira:
portaVendedor.send(pedido);

1. Ainda no agente Fabrica, crie uma função e a nomeie
checaOrdens
Processa os pedidos, enviando-os ao vendedor,
2. Na seção Function body, insira o código abaixo: enquanto houver pedidos na coleção ou
enquanto a fábrica tiver estoque suficiente
while(!pedidos.isEmpty()) {
Pedido pedido = pedidos.getFirst();
if(pedidos.getQuant() <= (int) invent) {
create_RealizaEntrega(uniform(), DAY, pedido);
invent -= pedido.getQuant();
pedidos.removeFirst();
}
else
break;
}
if(invent <= 2000)

taxaProducaoReal = taxaProducaoNormal();
else Regula a produção da fábrica
taxaProducaoReal = 0; conforme o nível de estoque

1. Volte ao editor do agente Vendedor e selecione a
porta de seu ícone
2. Edite as seguintes propriedades
̶ Na seção Message handling actions, insira o código
invent += msg.getQuant();
̶ Na seção Advanced, mude os campos In message
type e Out message type para Pedido

1. Ainda no editor do agente Vendedor, crie uma função e
a nomeie checaDemanda
2. Na seção Function body, insira o código abaixo Atende a demanda, decrementando o estoque Demanda,
// Checa se é possível atender a demanda, caso haja no agente Main, e incrementando o estoque Usuarios,
if((int) Demanda > 0) { de acordo com o inventário de produto disponível
int quantAtend = min(invent , (int) Demanda);
invent -= quantAtend;
main.atendDemanda(quantAtend);
}
// Checa se precisa fazer pedido à fábrica

if(invent < 1500) {
Realiza pedido à fábrica quando o inventário
int quant = uniform_discr(1500, 2000); cai abaixo de um nível mínimo especificado
Pedido pedido = new Pedido(quant);
portaFabrica.send(pedido);
}

De volta ao editor do Main, vamos adicionar dois Time plots, um para acompanhar o nível dos stocks
UsuariosEmPotencial e Usuarios, e o outro para acompanhar os inventários de produto
1. Arraste, da paleta de Analysis, um Time

plot e o posicione na porção inferior
esquerda da janela de visualização do
Main
2. Propriedades:
̶ Em Data, insira o título Usuários em
potencial e, em Value,
UsuariosEmPotencial
̶ Ainda em Data, clique em para
adicionar mais um plot e insira o título
Usuários e, em Value, Usuarios

3. Arraste, da paleta de Analysis, um novo
Time plot e o posicione na porção
inferior direita da janela de visualização
do Main
4. Propriedades:
̶ Em Data, insira o título Inventário -
vendedor e, em Value,
vendedor.invent
̶ Ainda em Data, clique em para
adicionar mais um plot e insira o título
Inventário - fábrica e, em Value,
fabrica.invent

Para finalizar, devemos criar um evento que,
diariamente, fará o processamento das ordens e
níveis de inventário do modelo. Para isso:
1. Da paleta de Agentes, crie um Event e o
nomeie InicioDia
2. Nas propriedades:
̶ Altere Mode para Cyclic
̶ Em Actions, insira o código
vendedor.checaDemanda();
fabrica.checaOrdens();
Supply Chain DS e AB – Fase 2 – Executando o modelo

Se você chegou até aqui, então o pior já passou. É hora de rodar o modelo, aproveite!
Desafio 5: resolvendo um
problema de Programação
Linear
Motivação
• Este exercício usará a importação de biblioteca externa para resolver um problema de
programação linear
• A importação de bibliotecas externas é útil quando se tem problemas para os quais se usa
ferramentas específicas para sua solução:
• Solução analítica de problemas de otimização. A biblioteca externa permite que se algoritmos
com métodos e/ou heurísticas consagradas sem a necessidade de implementá-los em cada
nova situação
• Importação de dados de arquivos com formatos não suportados originalmente pelo AnyLogic.
Este uso ocorre para a leitura de arquivos .json, por exemplo
Importação de bibliotecas Java

• O AnyLogic permite a importação de qualquer biblioteca externa Java no formato “.jar”
• Por isso, é chamado de software de “bordas infinitas”
• Um arquivo “.jar” é comumente usado para agregar classes Java e recursos associados,
como documentos de texto e imagens
• Exemplos de bibliotecas que podem ser importadas:
̶ Json
̶ Heurísticas
̶ Solver de programação linear e programação inteira
̶ Machine learning
Importação de arquivos jar
• O primeiro passo consiste em adicionar o arquivo .jar à lista de dependências do

modelo:
• Em seguida, devemos importar as classes, presentes nos arquivos .jar, que iremos
utilizar
• Isso deve ser feito no agente onde iremos utilizar as classes, na seção Advanced Java
> Imports section, nas propriedades do agente.
• Após estes passos, já podemos usar os métodos e instanciar objetos

com base nas classes importadas:
Desafio 4: resolvendo um problema de programação linear

• Iremos utilizar como exemplo o problema de split de materiais enfrentado por usinas de
carvão
• Ao ser processado, o fluxo de carvão de entrada divide-se em n materiais de saída (carvão
metalúrgico, carvão térmico, rejeito grosso, rejeito fino etc):
Carvão met.
Carvão térm.
Carvão MÓDULO
Rej. grosso
Rej. fino
Desafio 4: resolvendo um problema de programação linear

• Cada material de saída deve ser movimentado por um único equipamento
• Cada equipamento pode movimentar, no máximo, um material
• Há uma relação de prioridade entre cada par equipamento-material
Modelo matemático
• Conjuntos: • Modelo matemático:

̶ M: materiais
̶ E: Equipamentos
• Parâmetros: Sujeito a:
̶ 𝑝𝑚𝑒 : prioridade do material m ser
movimentado pelo equipamento e
• Variáveis de decisão:
̶ 𝑦𝑚𝑒 : material m movimentado pelo
equipamento e
Biblioteca utilizada
• Para a escrita do código que resolverá o modelo matemático com os dados inseridos,
utilizaremos o solver CLP, implementado na biblioteca clp-java
(https://github.com/quantego/clp-java/releases/tag/v1.16.11)
• A documentação da biblioteca pode ser acessada em http://quantego.github.io/clp-
java/overview-summary.html
• No código, usaremos o seguinte:
̶ A enum CLP.STATUS, que permite acessar o status da solução obtida (ótimo, inviável etc.)
̶ A classe CLP, que é instanciada para criar o modelo de PL que será resolvido e contém os
métodos utilizados no solver
̶ As classes CLPVariable e CLPExpression para a criação das variáveis de decisão e restrições
do problema a ser resolvido
Biblioteca utilizada
• Métodos utilizados
̶ addVariable(), para a adição das variáveis de decisão ao modelo, definindo
valores mínimos e máximos e o peso na função objetivo
̶ createExpression(), para a criação das restrições do problema, juntamente
com os métodos add(), para adicionar parcelas às restrições e leq() e eq(),
para estabelecer igualdades e desigualdades das restrições
̶ maximize(), para solução do problema
̶ getSolution(), para a obtenção dos resultados obtidos
Construindo o modelo de PL – Passo 0

1. Crie um novo modelo (File > New > Model) e nomeie-o Otimização PL
2. Importe o arquivo .jar disponibilizado, que contém a solver de programação linear
3. Na seção Advanced Java das propriedades do agente Main, insira o código de importação
das classes da biblioteca de PL:
import com.quantego.clp.CLP;
import com.quantego.clp.CLPExpression;
import com.quantego.clp.CLPVariable;

1. Na aba de projeto, selecione o
experimento Simulation: Main e arraste
para o editor gráfico duas variáveis:
A. Nomeie-as numMateriais e
numEquipamentos
B. Em propriedades, mude seus tipos para int
1. Ainda no Simulation: Main, arraste, da

paleta de Control, duas editbox,
nomeando-as numMateriais e
numEquipos
2. Nas propriedades, vincule-as (Link to) às
variáveis criadas

1. Da paleta Presentation, arraste dois textos para
o editor, acima dos editbox, para indicar a que
variáveis se referem (número de materiais e de
equipamentos)
2. Nas propriedades do experimento Simulation:
Main, procure pela seção Java actions e insira,
em Before simulation run*:
root.numEquipos = numEquipos;
root.numMateriais = numMateriais;
3. Desmarque a opção Skip experimente screen

and run the model
*Essas variáveis ainda serão criadas no agente Main


1. Copie as duas variáveis criadas no
experimento Simulation: Main e as cole no
editor do agente Main
2. Crie mais duas variáveis no editor do Main,
nomeando-as P e resultado. A primeira
será uma matriz de int, e a segunda, uma
matriz de double, ambas de tamanho
numMateriais x numEquipos

1. Da palea de Control, arraste uma editbox para o editor do Main, na posição x = 110 e y =
140, e ajuste sua largura para 40
2. Para que o número de editbox, que é onde serão inseridos os fatores de prioridades
(descritos no modelo matemático), seja flexível ao número de materiais e equipamentos,
usaremos replicações. Na seção Advanced das propriedades, insira
numMateriais*numEquipos em Replication:

3. Para que cada que seja gerada uma
disposição matricial dos editbox, a posição x e
y de cada replicação dependerá do seu índice.
Para isso, insira:
A. Em X: (index+1)%numEquipos*40+110
B. Em Y: (index)/numEquipos*50+140
4. Queremos que cada parâmetro preenchido
nos editbox replicados seja inserido na
variável P. Para isso, em actions, insira:
P[(index)/numEquipos][(index+1)%numEquipos]
= editbox.get(index).getIntValue();

• Vamos adicionar um elemento text que será usado para a escrita do modelo matemático do
nosso problema de programação linear
• Arraste, da paleta de Presentation, um Text para o editor do Main e o nomeie
textoResultado

Neste passo, o modelo matemático proposto
será implementado numa função, utilizando o
solver importado via biblioteca externa
1. Arraste uma Function para o Main e nomeie-
a optimize
2. Nas propriedades, insira como argumento:
A. numMateriais (type int)
B. numEquipos (type int)
C. P (type int[][])
• O código será tratado nos slides seguintes

3. Devemos marcar a opção Returns

value
A. Em Type, selecione a opção
Other...
B. Na caixa de texto ao lado, insira
double[][]

Inicialização da variável
de status da solução e da
variável do modelo
matemático
Inicialização das variáveis de

decisão e adição delas à
função objetivo
Inicialização das
restrições do modelo
matemático proposto

Define o tipo de
solução que se
deseja obter
(maximizar, neste
caso) Inicialização da variável
de resultados
Guarda e imprime os
resultados da otimização

Código na íntegra:
CLP.STATUS status; //solution status
CLP split = new com.quantego.clp.CLP().buffer(10000).maximization();
//Variaveis de decisao
CLPVariable[][] y = new CLPVariable[numMateriais][numEquipos];
//Adiciona variaveis ao problema já com seus pesos na função objetivo
for (int i=0; i<numMateriais; i++){

for(int j=0; j<numEquipos; j++){
y[i][j] = split.addVariable() //adiciona ao modelo
.lb(0.0) //limite inferior
.ub(1.0) //limite superior
.obj(P[i][j]) //peso na função objetivo
.name("y["+ (i+1) + "][" + (j+1) + "]"); //nome
}
}

//Restrições
for(int j=0; j<numEquipos;j++){
CLPExpression expr = split.createExpression();
for(int i=0; i<numMateriais; i++){
expr.add(y[i][j]);
}
expr.leq(1.0).name("Equipo " + (j+1) + " atende no máximo um material");
}
for(int i = 0; i < numMateriais; i++){

CLPExpression expr = split.createExpression();
for (int j = 0; j < numEquipos; j++){
expr.add(y[i][j]);
}
expr.eq(1.0).name("Material " + (i+1) + " atendido por um equipamento");
}
status = split.maximize();

double[][] result = new double[numMateriais][numEquipos];
if(status == CLP.STATUS.OPTIMAL){
for(int j = 0; j< numEquipos; j++)
result[i][j] = split.getSolution(y[i][j]);
}
String texto = split.toString()+ "\n\nResultado: \n";
for(int j = 0; j< numEquipos; j++)
texto += "y[" + (1+i) + "][" + (1+j) + "] = " + result[i][j] + "\n";
}
textoResultado.setText(texto);
return result;
}
else
return null;

Por fim, criaremos um botão que iniciará a otimização
1. Arraste um Button para o editor da Main, nomeie-o Otimize e, em Actions, insira
resultado = optimize(numMateriais, numEquipos, P);

Queremos visualizar o modelo matemático e o resultado na tela, além de outros textos
ilustrativos. Para isso:
• Adicione mais textos ao editor indicando o modelo matemático e os fatores de prioridade
Otimização PL – Executando o modelo

Se chegou até aqui, seu modelo está funcional e pronto para ser executado. Divirta-se!
Controle de versões - Git
Controle de versões: Git

• No desenvolvimento de software, costuma-se armazenar o histórico de desenvolvimento
por meio de um sistema de controle de versões ou sistemas de versionamento de código
• Por que utilizar:
̶ Armazenamento do histórico de desenvolvimento do software: versões, modificações e
responsáveis;
̶ Desenvolvedores podem trabalhar em paralelo, com funções de merge de modelos, por
exemplo.
• No git, o código é armazenado em uma árvore, que é composta por branches e

commits:
tempo
Merge
Branch
Commit
Ramificação/criação de um novo branch


• Exemplo do desenvolvimento de um projeto na Genoa:
• Dicas práticas para uso de um sistema de controle de versões com o AnyLogic:

̶ Quando vários desenvolvedores estiverem trabalhando no mesmo modelo ao mesmo tempo,
evitar que eles estejam realizando modificações no mesmo agente
̶ Action charts costumam causar problemas
̶ Um branch deve conter apenas uma nova funcionalidade ou correção, isto é, deve ser curto
̶ Se estiver trabalhando com mais pessoas, lembre sempre de:
̶ atualizar seu branch principal (master/develop) antes de criar novos branches usando o comando pull
̶ realizar um push, isto é, enviar a versão atualizada do seu código sempre que realizar um merge de volta
para o branch de origem
Controle de versões: GitHub

• O git fica instalado na máquina, ou seja, é um sistema local
• Cada projeto no git é um repositório local
• Para enviar um repositório para um servidor remoto e conseguir compartilhar o
desenvolvimento com outras pessoas, precisamos de um servidor de armazenamento
remoto. O mais popular deles é o GitHub
• O GitHub pode ser acessado diretamente pelo site ou pelo software instalado no
computador, o GitHub Desktop
• Principais alternativas ao GitHub Desktop: GitKraken, Sublime Merge e Visual Code

• Glossário
Termo/Ação Definição
Repositório Diretório onde ficam os arquivos do seu projeto, pode ser remoto (nuvem)
ou local (seu computador)
Clone de repositório Realizar uma cópia do repositório remoto (origin) no computador (local)
Commit Atualização dos arquivos do projeto no repositório local
Stage Definição de quais arquivos farão parte do commit
Merge Junção de dois branches
Branch Ramo/caminho paralelo do código
Pull Atualização o repositório local com informações da nuvem (usar quando
nuvem está mais atualizada que local)
Push Atualização a nuvem com informações do repositório local (usar quando o
repositório local estiver mais atualizado que a nuvem)
Conflito Ocorre quando a ferramenta de versionamento “não sabe” a versão do
branch a ser mantida no momento de um merge. Na maioria das vezes, é
resolvido automaticamente. Caso contrário, resolva manualmente
Desafio 6: construção
programática de objetos
de animação
Motivação
• Qualquer objeto pode ser criado via código, inclusive blocos das bibliotecas do AnyLogic,
agentes, caminhos, trilhos, rodovias, animações etc.
• Aqui, objetiva-se mostrar construtores de objetos para criação programática destes
• Muito útil quando o número de objetos a serem construídos deve ser genérico ou
dependente de algum parâmetro externo:
̶ Número de rotas de empilhadeiras em um armazém
̶ Número de pátios de armazenamento em um terminal portuário
̶ Comprimento de uma ferrovia
̶ Layout de uma estação de trem, shopping etc.
Construção programática de objetos

• Toda classe tem seu construtor, que deve ser respeitado. Muitas classes permitem
diferentes construtores, sendo possível utilizar qualquer um deles
• Muitas classes do AnyLogic possuem, no Help, detalhes avançados de criação com o
detalhamento de todos os argumentos possíveis de se utilizar
Construção programática de objetos

• Observando atentamente o Help, nota-se que, geralmente, há dois tópicos associados a um
objeto:
̶ Um mais básico, explanando seu uso;
̶ E um mais avançado (API), mostrando como construí-lo, seus construtores, métodos, etc.
Construção programática de objetos: fluxo de pessoas
• Para praticar a criação de objetos via

código, construiremos um modelo
simples de circulação de pessoas
• Utilizaremos como base o modelo
previamente fornecido, no qual o fluxo
de pedestres foi criado da maneira
tradicional, isto é, via drag & drop
Construção programática de objetos – Fase 0

Inicialmente, vamos entender o que o modelo fornecido representa:
Pedestres são criados no

aparecem na animação na Saem do sistema
targetLine da esquerda
Em seguida, movem-se
para a targetLine da direita
Construção programática de objetos – Fase 1 – Passo 1

• Crie variáveis representando as target lines e a parede central:

• Associe o aparecimento e desaparecimento dos agentes às novas target lines:

• Inicialize a variável targetLineChegada programaticamente, no campo “On startup”, no
Main:
targetLineChegada = new TargetLine( this, // Agent owner
SHAPE_DRAW_2D, //drawMode
true, //isPublic
250.0, //x
100.0, //y
new double[] { 0.0, 0.0, 0.0 }, //dx
new double[] { 0.0, 50.0, 0.0 }, //dy
green ); // color
• As coordenadas e pontos (vértices) podem ser copiadas da targetLine original, criada via
drag & drop:

• Analogamente, inicialize a variável targetLineSaida:
targetLineSaida = new TargetLine( this, // Agent
owner
SHAPE_DRAW_2D, //drawMode
true, //isPublic
600.0, //x
100.0, //y
new double[] { 0.0, 0.0, 0.0 }, //dx
new double[] { 0.0, 50.0, 0.0 }, //dy
green ); // color

• Finalmente, inicialize a variável paredeCentral:
paredeCentral = new RectangularWall(this, // Agent
owner
SHAPE_DRAW_2D3D, // drawMode
true, //isPublic
360.0, //x
70.0, //y
0.0, //z
150.0, //width
130.0, //height
0.0, //rotation
2.0, //line width
20.0, //z height
WALL_FILL_HATCHING, //filling type
peru ); //color
• Aqui também podemos nos basear na parede criada via drag & drop

• Inicializando o level:
Level level = new Level(this, "myLevel",
ShapeDrawMode.SHAPE_DRAW_2D3D, 0);
level.addAll( targetLineChegada, targetLineSaida,
paredeCentral );
level.initialize();
presentation.add(level);
• Levels são muito úteis pois permitem a modelagem de ambientes com mais de um andar ou
que estão em alturas diferentes, como estações de trem, shoppings, instalações de
mineração, armazéns etc.
• Além disso, facilitam a modelagem, uma vez que levels não selecionados ficam “travados”,
evitando movimentação acidental de objetos e figuras
• Agora, podemos apagar as target lines e

a parede que haviam sido criados via
drag & drop
• Ao executar o modelo, observa-se que
todos os objetos criados via código estão
funcionando e podem ser visualizados na
animação
Construção programática de objetos – Fase 2

• Nesta fase, vamos adicionar ao modelo um mapa de calor ao modelo
• Este elemento, chamado de density map no AnyLogic, é muito útil para a identificação de
gargalos de circulação de pessoas
• Pode ser adicionado de maneira tradicional, a partir da paleta, ou construído de maneira
programática
• A vantagem da construção programática deste elemento é mais evidente em modelos com
múltiplos andares, onde se deseja especificar quais andares devem conter um mapa de calor

• Crie uma variável referente ao density map:

• Inicialize o density map:

• Adicione o density map ao level:
Construção programática de objetos – Fase 2 – Executando o modelo

• Pronto, agora é só executar o modelo e visualizar o mapa de calor!
Importação de objetos
externos
Importação de objetos externos: objetos 3D

• Além da grande variedade de objetos 3D
disponíveis no AnyLogic, pode-se utilizar
arquivos externos
• Isso permite um maior nível de
personalização do modelo
• O formato utilizado pelo AnyLogic para
arquivos 3D é o COLLADA (.dae)
• Existem alguns sites que disponibilizam
modelos 3D para download gratuito:
̶ https://3dwarehouse.sketchup.com/
̶ https://free3d.com/pt/3d-models/collada
̶ https://sketchfab.com/tags/dae
̶ https://open3dmodel.com/pt/3d-
models/collada
Importação de objetos externos: objetos 3D – Fase 1 – Passo 1

• Para exemplificar a importação de objetos 3D, utilizaremos o modelo da seção de
construção programática de objetos
• O primeiro passo é adicionar uma janela 3D ao modelo:
Importação de objetos externos: objetos 3D – Fase 1 - Executando

• Ao observar a janela 3D, note que
ela não está focada em nenhum
lugar interessante;
• Após direcionar corretamente a
visualização 3D, clique com o botão
direito do mouse
• Note que aparece uma opção de
copiar a localização atual da
câmera. Copie

• De volta ao modelo, arraste uma câmera para o editor gráfico:
Navigation in 3D scene
• Drag the mouse to move the camera right, left, forward or

backward on the same height.
• Rotate the mouse wheel to move the camera closer or
further from the current center of the scene.
• Hold Alt (Mac OS: Option) + drag the mouse
to rotate the scene relative to the camera.

1. Em seguida, cole as coordenadas copiadas
anteriormente na câmera:
̶ Note que a câmera irá se deslocar na tela, até
as coordenadas inseridas
2. Finalmente, associe a janela 3D à câmera

• Agora, podemos ver claramente os cilindros ambulantes:
• Os cilindros são a animação 3D padrão do agente do tipo Agent

• Para conseguirmos uma animação personalizada, vamos criar um tipo novo de agente

• Vamos criar um novo tipo de Agente:

• Agora vamos importar o objeto 3D de um guerreiro viking:

1. Clique em no campo “File” nas propriedades do objeto 3D e encontre o arquivo
“model.dae”, na pasta “Modelo 3D” fornecida previamente:
2. Altere a “Additional scale” para 300%, para que o objeto fique visível na animação

1. Corrija a orientação do objeto:
2. Agora precisamos alterar o tipo de agente gerado pelo bloco pedSource:

Importação de objetos externos: objetos 3D – Fase 2 - Executando

• Ao executar o modelo, poderemos ver nosso exército viking:
Recursos de conectividade
Recursos de conectividade
• A paleta de conectividade apresenta blocos
que permitem uma conexão rápida com
̶ Documentos de texto
̶ Planilhas do Excel
̶ Banco de dados
Documentos de texto
• Para trabalhar com documentos de texto, basta arrastar um Text File para a área do editor
gráfico
Documentos de texto
• Conexão com um documento de texto: você deve vincular o Text File criado a partir da
paleta a um documento de texto do computador criado previamente
Documentos de texto
• Modo de utilização:
̶ Pode-se ler e escrever nos documentos de texto
̶ No caso da escrita, pode-se optar por limpar o arquivo a cada rodada (Write) ou não, isto é,
aproveitar o conteúdo previamente escrito (Write/Append)
Documentos de texto - Leitura

• Os métodos mais utilizados para leitura de documentos de texto são:
Função Ação
boolean canReadMore() Retorna true se ainda há conteúdo para leitura no
arquivo
String readString() Lê e retorna uma String do texto na posição de
leitura atual (ou seja, desde o separarador que o
antecede até o próximo separador)
char readChar() Lê e retorna um caracter

int readInt() Lê e retorna um valor do tipo int
double readDouble() Lê e retorna um valor do tipo double
float readFloat() Lê e retorna um valor do tipo float

• Define-se o separador nas propriedades do bloco

• A leitura de .txt’s é feita elemento a elemento, sendo definida pelo separador especificado, e
linha por linha (quando se seleciona a opção “Line separator”)
Exemplo Resultado:
Código:
Documentos de texto - Gravação

• Com relação à gravação, as funções mais importantes são
Função Ação
void setFile(String fileName, int mode) Define um novo arquivo que será utilizado pelo objeto do
tipoTextFile
Observações:
fileName – Caminho absoluto ou relativo em relação à
pasta de trabalho em uso
mode – Possíveis valores: READ, WRITE, WRITE_APPEND
void print(value) Imprime um determinado valor no arquivo

void println() Imprime um separador de linha no arquivo
void println(value) Imprime um determinado valor seguido por um
separador de linha no arquivo
void prinf(String format, Object args…) Imprime um texto (String) formatado com os argumentos
especificados

• Vejamos um exemplo
Observe que não

foi especificado
nenhum arquivo

Código: Resultados:

Podemos criar inúmeros arquivos .txt com uma única conexão
Excel
• Para trabalhar com arquivos Excel basta arrastar um bloco Excel File da Paleta de
conectividade e vincular a um arquivo já existente
Excel
• Também é possível arrastar o arquivo (.xls, .xlsx) diretamente na área do editor gráfico. O AL
cria automaticamente um com o arquivo adicionado
Excel
• O AnyLogic possui diversas funções para a utilização de arquivos Excel (sobrecarga de
métodos)
• Por isso, o ideal é buscar aquela que melhor encaixe às suas necessidades
• Com o comando “Ctrl + Espaço” você sempre pode ver as opções e a descrição do que cada
função faz
Excel - Leitura
• Para atualizar os dados antes de se executar o modelo, selecione a opção Load on model
startup ou utilize a função readFile() antes de realizar outras ações no arquivo Excel
Excel - Leitura
• Algumas funções úteis para leitura de arquivos Excel
Função Ação
void readFile() Carrega os dados do arquivo
boolean getCellBooleanValue() Retorna o valor da célula como um valor booleano
double getCellNumericValue() Retorna o valor da célula como um número
String getCellStringValue() Retorna o valor da célula como um String
String getCellFormula() Retorna a fórmula da célula, por exemplo SUM(C4:E4)
int getFirstRowNum() Retorna a primeira linha da planilha
Int getFirstCellNum() Retorna a primeira coluna preenchida em uma dada

linha
Int getLastRowNum() Retorna a última linha preenchida da planilha
int getLastCellNum() Retorna o índice (coluna) da última célula preenchida

em uma dada linha
Excel - Leitura
Exemplo:
A primeira planilha também é aquela
de número 1
Código:
Observe que a contagem de linhas e colunas

começa em 1, não em 0, como no Java
Resultado:
Excel - Leitura
Exemplo:
Código:
Resultado:
Excel - Gravação
• Utilize sempre a opção Save on model termination ou a função writeFile() para salvar suas
alterações no arquivo Excel.
Excel – Gravação
• Funções úteis para gravação de dados no Excel
Função Ação
void writeFile() Salva as mudanças no arquivo Excel
void setCellFormula() Atribui uma fórmula à celula
void setCellValue() Atribui um valor à célula (booleano, número, string...)
int writeDataSet() Escreve os valores de um dataset na planilha,

começando de uma determinada célula
void clearCell() Limpa a célula especificada (tipo e valor)
void createCell() Cria uma nova célula
void setFileName() Troca o arquivo vinculado por um outro arquivo

Excel - Gravação
Exemplo: Resultado:
Código:
Excel - Gravação
Exemplo: Resultado:
Código:
Database
• O AnyLogic possui um database integrado para ler dados de entrada ou

escrever resultados de experimentos
• Nele, pode-se criar tabelas com dados importados de arquivos externos (por
exemplo, planilhas de Excel)
Database – Criação de tabelas

• Na criação de uma tabela, pode-se optar pela inicialização de uma tabela vazia (1),
inicialização de uma tabela com dados externos (2) ou com dados de uma planilha na área
de transferência (3)
(1)
(2)
(3)

1) Os dados são inseridos manualmente. Colunas podem ser adicionadas em e
removidas em

2) Escolhe-se um arquivo externo contendo o banco de dados que se deseja utilizar no
modelo (por exemplo Excel)
Seleciona as planilhas
do arquivo
Escolhe o arquivo

3) Primeiro, copia-se os dados desejados para que sejam enviados à área de transferência. A
tabela será criada com estes dados
Database – Consultando dados

• Uma maneira de se fazer consultas aos dados do database é através da função
selectFrom(). Pode-se inclusive consultar os dados e guardá-los em variáveis para
manipulação

• O AnyLogic oferece, ainda, uma facilidade a mais para se fazer consultas ao database,
através uso do Query Constructor
• O Query Constructor permite que os usuários construam visualmente consultas ao banco de
dados do AnyLogic. Não é preciso escrever consultas SQL manualmente, apenas construir a
consulta graficamente usando controles, e o AnyLogic automaticamente constrói a consulta
correspondente e a insere do campo desejado

• Para utilizar o Query Constructor, selecione um campo onde se deseja inserir uma consulta
ao database, e, então a opção se tornará disponível na barra de propriedades superior do
AnyLogic
• No exemplo abaixo, queremos realizar uma consulta no início da simulação:
Seleciona a tabela
Estabelece a condição
Seleciona a coluna de escolha dos valores:
dos valores desejados
Seleciona a ação para

ser executada com os
dados que satisfazem a
condição estabelecida
Exibe o comando
que será inserido
no campo
selecionado
Desafio 7: Modelagem de
um virador de vagões
Motivação
• A biblioteca ferroviária é uma das bibliotecas

verticais com menos blocos do AnyLogic e
uma das mais complexas, pois permite uma
grande variedade de políticas e formas de
controle do tráfego ferroviário
• Pode ser utilizada conjuntamente com
outras bibliotecas, como a de processos e a
de pedestres
• Utilização:
̶ Pátios de carga e descarga de terminais
̶ Ferrovias de qualquer escala ou
complexidade
̶ Estações de trem
̶ Etc
Motivação
• Neste projeto básico, iremos modelar um “virador” de vagões simplificado. Nos
preocuparemos apenas com as operações de movimentação do trem, desprezando o
tratamento dos estoques, equipamentos, carga e demais elementos que não dizem
respeito à biblioteca de ferrovias
• Neste sistema, o trem é criado e se move até um pátio de espera e, em seguida, vai até o
virador
• Os vagões são descarregados (virados) e dirigem-se para o final do trilho, onde esperam os
demais vagões
• Quando todos os vagões são descarregados, o trem vazio segue viagem e sai do sistema
considerado
Motivação
• Ao longo do desenvolvimento do modelo, iremos utilizar:
̶ Listas
̶ Funções
̶ Database
̶ Custom distribution
• Iremos desenvolver formas de visualização 3D que enriquecem muito o modelo:
colocaremos uma câmera no trem e criaremos uma câmera “drone”, que observa o
processo de cima
Sobre o desafio
• O exercício está organizado em 4 fases:
̶ Fase 1: construção da lógica e demais elementos básicos do modelo
̶ Fase 2: construção da visualização 3D do modelo e implementação de uma câmera que
acompanha o trem
̶ Fase 3: implementação de uma câmera “drone” e complementação da navegabilidade pela
interface gráfica do modelo
̶ Fase 4: Uso de recursos de conectividade (database) e dados (custom distribution)
• A fase 1 não traz conteúdos novos que fazem parte dos objetivos de aprendizagem deste
desafio, então será disponibilizado o modelo com a fase 1 pronta, e partiremos da fase 2
• Os passos para desenvolvimento da primeira fase estão disponíveis neste material para uma
breve passagem e para consulta posterior dos alunos
Virador de Vagões – Fase 1 – Passo 1

1. No canto superior direito, clique em: File > New > Model
2. Em Model name, digite Virador de Vagões, selecione minutes em Model time units e, por
fim, clique em Finish

Podemos passar agora para a construção dos trilhos onde toda a operação vai ocorrer. Para
isso:
1. Na aba de paleta, na parte da biblioteca ferroviária, dê um clique duplo sobre Railway
Track

2. No editor gráfico, comece por uma linha singela de boa extensão. Numa porção indo de,
aproximadamente, um quarto até metade da via, adicione um trecho de trilho superior e
outro inferior a linha singela, que representarão os pátios de espera de trens
Representação
dos pátios

• Dica: Para construir trechos curvos pressione e segure o botão esquerdo do mouse na
posição onde o trecho acaba e, por fim, mova-o. Note que, ao mover o mouse, é possível
alterar a curva. Solte o botão somente quando o segmento atingir a forma desejada
Trecho com curva


A nossa ferrovia deve ficar com este aspecto:
• É importante que ela tenha estes trechos bem amplos para que os trens caibam. Caso
contrário, o modelo pode apresentar erros durante a simulação

3. Da paleta ferroviária, adicione, nas posições indicadas na figura, Position on Tracks,
seguindo a nomenclatura adotada na imagem
patio3
patio2
aguardaPatio
patio1

3. Da paleta ferroviária, adicione, nas posições indicadas na figura, Position on Tracks,
seguindo a nomenclatura adotada na imagem
finalLinha
virador
prepOp

4. Por fim, selecione o trecho de ferrovia que contém o prepOp, virador e finalLinha e o
renomeie como trilhoVirador
trilhoVirador

Dando continuidade, vamos agora criar os agentes que existirão no modelo:
1. Trem
2. Vagão

• Trem:
1. Na paleta de Rail Library, arraste e solte um Train Type no editor do Main
2. Clique em Finish

1. Vagão:
1. Arraste e solte um Agent no Main
2. Clique em Next
3. Mantenha a animação 3D e selecione o BoxCar. Finalmente, clique em Finish
• Dentro do agente Train, vamos adicionar

uma variável. Para isso:
• Da paleta de agentes, arraste e solte uma
variável, nomeando-a patio
• Na aba de propriedades, vamos configurar o
tipo dessa variável. Selecione:
̶ Other no campo Type
̶ Digite PositionOnTrack no campo ao lado

Agora, dentro do agente Main, criaremos uma coleção e uma função:
• A coleção representará os pátios do trecho. Toda vez que um pátio estiver em uso, ele será
reservado ao trem que estiver nele, para que trens subsequentes não sejam mandados a
ele. Quando o pátio voltar a ficar livre, a reserva do trilho será cancelada
• A função servirá para realizar a operação descrita acima. O primeiro elemento da coleção
de pátios que estiver livre (ou seja, sem reservas) terá seu trilho alocado ao trem que
chegar, sendo reservado

Para criar estes elementos, segue-se o mesmo processo: arraste, solte e nomeie
• patios para a coleção

• getPatio para a função

Na aba de propriedades da coleção de pátios:
1. Selecione, em Collection class, a opção LinkedList
2. Em Elements class, selecione Other... e, na caixa ao lado, escreva PositionOnTrack
3. Em Initial contents, clique no sinal de soma e adicione os Position on Track dos pátios

Nas propriedades da função getPatio:
1. Selecione a opção Returns value, selecione Other...
em type e escreva PositionOnTrack na de texto ao
lado
2. Na seção Arguments, dê o nome de train e
selecione Train na caixa de Type
3. Em Function body, escreva o seguinte código:
PositionOnTrack<?> POT = findFirst(
patios, p ->
p.getTrack().reservations().isEmpty() &&
p.getTrack().getTrains().isEmpty());
POT.getTrack().reserveFor(train);
train.patio = POT;
A função findFirst() busca o primeiro elemento
em uma coleção que satisfaz as condições desejadas.
return POT; Neste caso, queremos o primeiro pátio sem reservas
e que esteja sem trens.

Podemos, a partir de agora, começar a construir a lógica do modelo. Para isso, “drag and drop”
os blocos mostrados de acordo com a figura abaixo. Os blocos de cor laranja pertencem à
biblioteca ferroviária; os blocos azuis pertencem à biblioteca de processos:
A cada operação de acoplar ou

desacoplar são criados novos trens,
por estarmos lidando com um novo
conjunto de vagões

Aqui, exibem-se as propriedades que devem ser modificadas/inseridas nos blocos. Os que não
são citados devem ser deixados em seus valores padrões
Arrivals defined by: Calls of inject() function
Position on track: aguardaPatio
Train type: Train
Rail car type: RailCar
Route is: Calculated automatically

From current to target track
Target is: A given position on track
Position on track: getPatio(train)
Finish options: Desacelerate if condition is true
Desacelerate if: !trilhoVirador.isEmpty()
Train type: Train

Maximum capacity:
Position on Track: prepOp
Agent type: Train
Finish options: Desacelerate and stop
Train type: Train
Capacity (max allowed): 1

Agent type: Train
On enter:
agent.patio.getTrack().cancelReservation();

Type: Until stopDelay() is called
Agent type: Train
New train: Train
Train1 type: Train
Train2 type: Train Delay time: triangular( 5, 10, 15 )
On exit:
aguardaVirarVagao.stopDelayForAll();
Agent type: Train

Position on track: virador
Finish options: Desacelerate and stop
Train type: Train

Select true output: If condition is true
Route is: Calculated automatically Condition: agent.size()<11
From current to target track Train1 type: Train
Position on track: finalLinha
Train type: Train
Train1 type: Train

Train2 type: Train

Train type: Train
RestrictedAreaStart object:
RestrictedAreaStart
Agent type: Train

• Para encerrar esta fase do modelo, devemos “ativar” o surgimento dos trens na via
• Para isso, note que, ao preenchermos as propriedades do primeiro bloco da lógica,
trainSource, configuramos que as chegadas seriam definidas pela “chamada” da função
inject()
• Devemos, então, definir como aquela função será chamada. Faremos isso através de um
botão que deve ser pressionado pelo usuário durante a simulação
• Devemos tomar o cuidado de o usuário não gerar trens e não haver pátio disponível para
recebê-los. Para isso, a condição para que um trem seja gerado no sistema é que haja pelo
menos um pátio sem reservas e sem trens passando por ele

1. Da paleta de Controls, arraste e solte no editor do Main um Button

2. Nas propriedades, dê um nome para o botão, digitando-o em Label, e insira o seguinte
código em Action:
boolean temPatio = false;

for(PositionOnTrack<?> POT: patios){
if(POT.getTrack().reservations().isEmpty() &&
POT.getTrack().getTrains().isEmpty())
temPatio = true;
}
if(temPatio)
trainSource.inject();
Virador de Vagões – Executando o modelo

Cumpridas todas as etapas anteriores, o modelo está pronto para ser executado. Sendo assim,
dê um clique em e veja a simulação acontecer!

Veja também o que ocorre na lógica durante a simulação!
Virador de Vagões - Continuação

• Pretendemos agora deixar a visualização do modelo durante a simulação um pouco mais
empolgante
• Para tal, vamos adicionar um visualização 3D do modelo, com uma câmera no trem (Fase 2)
e uma câmera “drone” (Fase 3), que se moverá pelo espaço da ferrovia ao longo da
simulação
• Antes, porém, precisamos alterar a velocidade da simulação, para podermos acompanhar
bem a operação dos trens, e alterar a posição do botão Injeta Trem
Virador de Vagões - Continuação

1. Na aba de projetos, dê um clique sobre o Simulation: Main e, nas propriedades, na seção
Model time, selecione 1/10 na caixa de seleção ao lado da opção Real time with scale
2. Arraste e solte o botão para o canto superior esquerdo do retângulo azul sobre a ferrovia

1. Da paleta de Presentation, arraste e solte, no Main, uma 3D Window e, na seção Position
and size, nas propriedades, configure a altura para 570, largura para 1000 e Y para 30 ;

• Ainda da paleta de Presentation, arraste e solte duas View áreas sobre o Main, uma sobre a
ferrovia e outra sobre a janela 3D, nomeando-as viewArea2D e viewArea3D,
respectivamente
̶ Posicione a viewArea2D para que esta fique exatamente sobre o retângulo azul sobre e o trecho
final da ferrovia
̶ Faça o mesmo com a viewArea3D, de modo a “sobrar” 30 pixels para cima em relação a janela
3D

Agora, vamos tratar dos botões. A ideia é que, além de deixar o Injeta trem visível na tela (1),
possamos alternar entre a simulação 2D e 3D (2). Para isso:
1. Copie e cole (ou arraste segurando Ctrl) o botão Injeta trem para o canto superior esquerdo
da viewArea3D;

2. Da paleta de Control, arraste e solte dois Button, cada um deles exatamente ao lado dos
botões Injeta trem
A. No botão criado na viewArea2D, vá nas propriedades, insira o texto 3D em

Label e, na seção Action, digite: viewArea3D.navigateTo();
B. No botão criado na viewArea3D, vá nas propriedades, insira o texto 2D em

Label e, na seção Action, digite: viewArea2D.navigateTo();


Podemos, agora, tratar da câmera, que acompanhará trem. Para isso:
1. Abra o agente RailCar
2. Da paleta de Presentation, arraste e solte uma Camera no editor gráfico, pouco atrás (à
esquerda) da representação do vagão

3. Nas propriedades da câmera, configure o seguinte:
̶ Em Rotation X, insira 15, o que fará a câmera “olhar” para baixo de 15°;
̶ Na seção Position, insira -200 para a posição X, 0 para a posição Y e 60 para a posição Z.
4. Para finalizar, volte ao agente Main e, na lógica, selecione o bloco trainSource

5. Na seção Actions das propriedades, insira em On exit:
window3d.setCamera(((RailCar)train.getLast()).camera, true);
Este código selecionará a câmera do último vagão para ser exibida na janela 3D durante a
simulação

Para finalizar e deixar a visualização um pouco
mais realista, vamos adicionar um chão
gramado no modelo. Nesta tarefa:
1. Na paleta de Presentation, dê um clique
duplo em Polyline;
2. Desenhe, ao longo de toda a ferrovia, uma
área poligonal;
3. Na seção Appearance das propriedades, vá
em Fill color, onde, então, deve selecionar
Textures... e clicar na verde (grass)

4. Ainda nas propriedades, na seção Position and size,
garanta que a posição Z e Z-Height sejam igual a 0
5. Ao criarmos o gramado, talvez ele tenha ficado por
cima dos trilho. Para resolver, clique em qualquer
ponto dele e vá em Order > Send to back

Seguidos os passos descritos, este deve ser o resultado que se obterá para a ferrovia e os
entornos dela:

Se todos os passos anteriores foram seguidos corretamente, você pode agora executar o
modelo e se divertir com a animação!

Nesta etapa, pretende-se criar uma nova câmera, que, desta vez, vai ficar sobrevoando a área
da ferrovia, como se fosse um drone.

Para começar, criaremos quatro variáveis auxiliares:
1. Arraste e solte, da paleta Agents, quatro variáveis no Main. Nomeie-as:
A. tremAtual: Criaremos um botão que selecionará a câmera que segue o trem.
Contudo, fora da lógica, é necessário usar um artifício para referenciar o trem e
mudar a câmera, e para isso servirá está variável. Esta variável será do tipo
Train
B. vagaoReferencia: A câmera “drone” voará pela área da ferrovia, “orbitando”
um vagão de referência (número 5, neste caso) do último trem inserido nos
trilhos. Esta variável será do tipo RailCar

C. tempo: Para padronizar a “órbita” da câmera para cada trem, usaremos essa
variável para guardar o instante de criação deste. A órbita da câmera variará
com time()-tempo, de modo que sempre se inicie do valor 0. Esta variável
será do tipo double
D. trensNoSistema: esta variável contará a quantidade de trens no sistema. Ela
será importante para a atualização das variáveis tremAtual e vagaoReferencia
quando não houver mais trens da ferrovia


2. No bloco trainSource, apague o código anterior e
insira o seguinte código abaixo no campo On exit:
da seção Actions, das propriedades:
tremAtual = train;
vagaoReferencia =
(RailCar)tremAtual.getCar(5);
tempo = time();
trensNoSistema++;

3. No bloco trainDispose, insira na seção On enter, das propriedades, o código:
trensNoSistema--;
if(trensNoSistema == 0){
vagaoReferencia = null;
tremAtual = null;
}

Vamos, agora, adicionar a câmera no modelo. Para isso:
• Da paleta Presentation, arraste e solte uma câmera no Main. Desta vez, não precisamos nos
preocupar muito com a posição inicial dela, já que a ideia é que ela se mova
• Posicione-a perto dos trilhos

Agora, é hora de inserir a “mágica” do drone. Trata-se apenas de um código que descreve sua
posição no espaço, variando no tempo e com a posição do vagão de referência. Nas
propriedades, para os campos indicados, clique no sinal de igual ( ), fazendo aparecer e
insira:
• Em Rotation Z, rad:
vagaoReferencia != null ? PI - ( time() - tempo)*3. : -PI/4
• Em X:
vagaoReferencia != null ? vagaoReferencia.getPosition().x - sin((time()-
tempo)*3)*200 +400 : -1836
• Em Y:
vagaoReferencia != null ? vagaoReferencia.getPosition().y + cos((time()-
tempo)*3+PI/2)*200 : 736


Agora, vamos adicionar os botões que mudarão da câmera do trem para a câmera “drone”.
Para isso:
• Da paleta Control, arraste e solte dois Check box, na viewArea3D, ao lado do botão 2D;
• Nas propriedades, insira câmera no trem (A) e drone (B) nos Label dos botões

1. Em Actions, insira:
if(tremAtual != null){
window3d.setCamera(((RailCar)tremAtual.getLast()).camera, true);
checkbox1.setSelected(false);
}
else
throw new RuntimeException("Não há trens na ferrovia.");

2. Em Default value, insira true, e, em Actions:
window3d.setCamera( camera, true );
checkbox.setSelected(false);
Um cuidado especial é dado para o primeiro botão, pois a câmera no trem só pode ser
selecionada se houver trem na ferrovia

Para finalizar, queremos que o botão câmera no trem só
funcione quando houver trem na ferrovia, caso contrário, a
câmera drone deve ser selecionada automaticamente. Para
isso ocorrer, substitua o código do bloco trainDispose pelo
seguinte código:
trensNoSistema--;
if(trensNoSistema == 0){
vagaoReferencia = null;
tremAtual = null;
if(checkbox.isSelected())
checkbox1.setSelected(true, true);
}

Se você chegou até aqui, parabéns! Execute o modelo e divirta-se!
Virador de Vagões – Fase 4

• Nesta fase, pretendemos mostrar o uso conjunto de duas novas funcionalidades: Custom
Distribution e Database
• Vamos inserir uma distribuição personalizada para o tempo em que os vagões
permanecem no virador
• Os dados para essa distribuição serão inseridos numa planilha de Excel e importados para o
Database do modelo
• Os tempos no virador poderão ser visualizados num histograma inserido na simulação

1. Da paleta de agentes, arraste para o editor gráfico do Main um Custom Distribution,
nomeando-o tempoVirador
2. Nas propriedades, selecione o tipo Continuous e Frequency table em Define using:
1. Na aba de projeto, selecione o Database e,

em seguida, clique em Create or import a
table... para importar o arquivo .xlsx com
os dados para a distribuição
̶ Nas propriedades do database, marque a
opção Autoupdate imported tables on model
startup
2. Volte às propriedades do tempoVirador e,
na seção Data, marque a opção Loaded
from database
̶ Em Table, selecione a tabela tempos, criada
no database
̶ Em Value column, selecione valor
̶ Em Weight column, selecione frequência
3. No Main, selecione o bloquinho

virandoVagao. Lá, nós vamos
chamar o método que vai utilizar a
Custom Distribution implementada
̶ No campo Delay time, insira o
código tempoVirador()

A essa altura, a distribuição personalizada já
está funcionando. Queremos, agora, visualizá-
la durante a simulação. Para isso:
1. Arraste um Histogram data, da paleta de
Analisys, para o Main, nomeando-o
histogramaVirador
2. Clique nele com o botão direito do mouse
e selecione Create Chart, posicionando-o
no canto inferior direito da viewArea2D
̶ Nas propriedades, dê o título de Tempo no
virador
̶ Sugere-se mudar a cor dos labels e da
legenda para melhorar a visualização

Para finalizar, deve-se implementar a coleta de tempos:
1. Arraste para o Train uma nova variável e nomeie-a t0 (tipo double)
2. Nas propriedades do bloco virandoVagao, insira os códigos:
A. Em On enter: agent.t0 = time();
B. Em On exit: histogramaVirador.add((time()-agent.t0)*60);

Pronto! Agora é possível inserir (e observar) distribuições personalizadas no seu modelo!
Debugger
1. Código em Java: permite ver o código sendo executado e adicionar novos breakpoints;
2. Breakpoints existentes: permite ativar e desativar os breakpoints
3. Variáveis: mostra todas as variáveis do agente atual sendo possível a navegação através da árvore
apresentada
4. Expressions: permite adicionar expressões que são executadas neste ponto em específico. Junto as
variáveis permite a verificação do que está acontecendo no modelo a cada momento
2
4
3
1
Desafio 8:
Desenvolvimento de
blocos e bibliotecas
personalizadas
Motivação
• Blocos personalizados são muito úteis para tornar o fluxo mais conciso, facilitando a
interpretação
• Podem ser utilizados para a interconexão de modelos e para gerenciamento de trechos
repetitivos de código
• Neste exercício, vamos usar como base o modelo desenvolvido no Desafio #5:
construiremos um bloco representando o virador de vagões
Criação de blocos e bibliotecas personalizados – Fase 1 – Passo 1

Nesta primeira etapa, criaremos um bloco de lógica personalizado a partir do virador de
vagões
1. Crie um novo Agent type e nomeie-o ViradorVagoes
2. Selecione todos os blocos pertencentes ao virador e recorte (Ctrl + X):
Criação de blocos e bibliotecas personalizados– Fase 1 – Passo 1

3. Em seguida, cole os blocos selecionados no novo agente ViradorVagoes:

Agora, vamos criar o ícone do nosso bloco:
1. Arraste uma imagem para o editor gráfico (Paleta Presentation > Image) e selecione o
arquivo “virador32.png”
2. Da paleta Agent arraste dois elementos Port para próximo do ícone do virador:
Desmarque a opção “Show name”

nas propriedades das ports

3. Selecione a imagem do virador e marque a opção Icon nas suas propriedades:

• Nas propriedades da imagem, vá em Advanced > On click e escreva “return true”
Este comando permite que, durante a execução do modelo, possamos clicar no ícone do
virador e “entrar” no agente

• Conecte o ícone à lógica utilizando as portas criadas:

• Conecte agora nosso novo bloco ao fluxo existente no Main
Arraste um agente
ViradorVagoes na área do Main
Conecte o
novo bloco ao
fluxo
Criação de blocos e bibliotecas personalizados – Fase 1

• Ao compilar o modelo (F7), obteremos alguns erros:
• Estes erros aconteceram pois os position on track e outros dados usados não estão no
virador, e a referência não está correta
• Podemos, simplesmente, corrigir a referência, adicionando main. antes da referência aos
position on track
• Porém, isto seria ruim para o uso deste bloco com outros agentes que não o Main, ou
mesmo em outros modelos, caso fosse compilado como uma biblioteca

A melhor forma de resolver esse problema é parametrizando os dados necessários
• prepOp (PositionOnTrack)
• finalLinha (PositionOnTrack)
• virador (PositionOnTrack)
• tempoVirador

Primeiramente, vamos parametrizar os Position on track
1. Crie 3 parâmetros do tipo PositionOnTrack no agente ViradorVagoes, nomeando-os
prepOp, finalLinha e virador
2. Além disso, altere o label e o Control type dos 3 parâmetros

Em seguida, criaremos um parâmetro para o tempoVirador
1. Crie um parâmetro do tipo double, chamado tempoVirador
2. Na seção Value editor, corrija o Label para Tempo virador [s]
3. Em Advanced Marque a opção Dynamic, pois ele varia de acordo com uma Custom
Distribution

• Passe o gráfico e o bloco de histograma relativo ao tempos do virador para dentro do agente
ViradorVagoes (Ctrl + x)
Devemos alterar a cor do texto

da legenda do histograma!

• Voltando ao Main, clique no bloco do virador e associe cada parâmetro ao seu respectivo
position on track
• Note que podemos escolher o position on track selecionando-os na lista suspensa

• Isso é possível pois escolhemos Element chooser no Control type dos parâmetros

• No campo Tempo virador [s], escreva tempoVirador()
• Isso associa a Custom Distribution criada no Main ao parâmetro dinâmico dentro do bloco
ViradorVagoes
Por fim, note que blocos do AnyLogic possuem uma aba “Actions” com campos (On enter, On exit...)
onde o usuário pode programar certas ações. Em nosso bloco, no entanto, essa opção não aparece

Vamos personalizar o bloco para que este tenha uma aba Actions e campos onde possamos
definir ações.
1. Dentro do agente ViradorVagoes , crie dois parâmetros, chamados onEnter e onExit

2. Em Advanced, selecione a opção Action
3. Insira como argumento do parâmetro um parâmetro do tipo Train, chame-o de train
4. Escreva um texto para o Label, como “On enter:”, “On exit:”

• Adicione blocos do tipo Plain Transfer (da paleta Process Modelling Library) na entrada e na
saída do processo

1. No Plain Transfer de entrada (plainTransferEntrada), chame o parâmetro onEnter criado,
passando, como argumento, o agent:
2. No campo Agent type, em Advanced, selecione Train

2. Faça o mesmo no Plain Transfer de saída (plainTransferSaida), escrevendo agora
onExit(agent);

1. Nas propriedades do agente ViradorVagoes, clique sobre o campo “On enter:” e selecione
Begin section
2. Escreva “Actions” (ou o texto que preferir)

1. Volte ao Main, clique no bloco ViradorVagoes e veja as mudanças
2. Podemos passar o código do bloco restrictedAreaStart para o campo On enter do bloco do
ViradorVagoes:
̶ Troque agent por train
Adicione duas barras (“//”) ao início

do código para deixa-lo comentado
Criação de blocos e bibliotecas personalizados – Fase 1 – Executando o

modelo
• Agora podemos executar o modelo:

O AnyLogic permite a criação e adição de novas bibliotecas à sua paleta de bibliotecas;
Exemplos:
Blocos de mineração:
Extração na lavra
Carregamento/descarga de caminhões
Britador Biblioteca de mineração
Silo de armazenagem
Blocos ferroviários:
Pátio de cruzamento de trens
Pátio de manutenção
Biblioteca ferroviária
Trecho de linha singela
Trecho de linha dupla
Blocos portuários:
Descarga de trens
Biblioteca portuária
Embarque/desembarque de navios
Pátios de armazenagem

Nesta etapa, vamos transformar o virador de vagões desenvolvido em um bloco de uma nova
biblioteca. Agora, exportaremos aquele bloco numa biblioteca personalizada
• Crie uma nova biblioteca, chamando-a de “Biblioteca Portuária”
(1) Insira o arquivo

ícone_biblioteca.png
(2) Marque o agente

(4) Exporte a
ViradorVagoes para
biblioteca
incluí-lo na nova
biblioteca
(3)-(4) Insira os arquivos

referentes ao ícone do
virador
Obs: é necessário clicar
sobre o nome do agente a
exportar

• A exportação da biblioteca irá criar o
arquivo “BibliotecaPortuaria.jar”
• Agora, devemos fechar o modelo aberto no

AnyLogic para podermos adicionar a nova
biblioteca: Palette > > Manage Libraries...
Clique em Add na caixa que irá se abrir e selecione o arquivo “BibliotecaPortuaria.jar”:
Finalmente, clique em Ok
Criação de bibliotecas: virador de vagões – Fase 2

Agora, nossa biblioteca aparece na paleta do AnyLogic e o bloco referente ao virador de vagões
pode ser utilizado e acoplado a outros modelos:
Custom experiment
Custom experiment
• O AnyLogic possui vários experimentos, para muitas finalidades
• Entretanto, ainda assim, às vezes mais flexibilidade é necessária
• O Custom experiment dá ao usuário uma tela em branco para:
̶ Gerenciar parâmetros
̶ Executar outros experimentos (Ex: um experimento “chama” o outro)
̶ Criar experimentos com mais profundidade que os experimentos padrão
Custom experiment
• Para ilustrar o uso do custom experimente, iremos desenvolver um experimento de
otimização
• Usaremos um modelo simples de um banco como ponto de partida
Custom experiment
• Neste modelo de simulação simplificado de um banco, os clientes têm duas opções de
atendimento:
̶ Caixa
̶ Caixa eletrônico
• Cada serviço possui sua própria fila, de capacidade infinita, e uma distribuição de tempo de
atendimento distinta.
Banco - Introdução ao modelo
Capacidade da fila: infinita

70% escolhe o serviço
TA: Triangular(0.5, 1.0, 1.5) [min]
de caixa eletrônico
Taxa de chegada:
5 clientes/minuto
Capacidade da fila: infinita

TA: Triangular(2.5, 6.0, 11) [min]
Cada serviço
está associado
a um recurso
A capacidade dos recursos

está associada a parâmetros
As estatísticas de tempo
em fila são coletadas e
armazenadas nos blocos
tempoFilaCaixaElet e
tempoFila Caixa
Os gráficos mostram o tempo

médio em fila para cada serviço

Banco – Executando o modelo
Observe que o tempo médio em

fila é sempre 0 utilizando 20
caixas eletrônicos e 20 caixas
Banco – Custom Experiment

• O número de caixas e de caixas eletrônicos está superestimado.
• Queremos otimizar a capacidade desses recursos, garantindo um certo nível de serviço.
• Como fazer isso utilizando o Custom Experiment?
Fase 1 – Entendendo o Custom Experiment

Nesta primeira fase, vamos conhecer o Custom Experiment olhando o exemplo de otimização
feito no modelo do banco.
As características do problema são as seguintes:
• O nível de serviço será medido pelo tempo médio de espera em fila nos caixas.
• Queremos que esse tempo seja de, no máximo, 3.0 minutos.
• Para atingir este nível de serviço, quantos caixas são necessários?
Vamos entender passo a passo como isso é feito!

Banco – Fase 1
Banco – Fase 1
Banco – Fase 1
Banco – Fase 1
Banco – Fase 1
Banco – Fase 1
Banco – Fase 1
Banco – Fase 1
Banco – Fase 1
Banco – Fase 1
Banco – Fase 1
Banco – Fase 1
Banco – Fase 1
Banco – Fase 1
Banco – Fase 1
Banco – Fase 1
Banco – Fase 1
Banco – Fase 1
Banco – Fase 1
Banco – Executando o modelo

• Ao final, descobrimos que o número ótimo de caixas é 11, para a condição de tempo médio
em fila no caixa de no máximo 3.0 minutos.
Fase 2 - Desafio
• Até o momento, otimizamos somente o número de caixas
• Nesta segunda fase, queremos otimizar também o número de caixas eletrônicos
• O tempo médio de espera em fila para o serviço de caixa eletrônico deve ser menor que 1.0
minuto
• O tempo médio de espera em fila para o serviço de caixa deve ser menor que 3.0 minutos
• Qual é o número mínimo de caixas e de caixas eletrônicos necessário para se atingir esse
novo nível de serviço?
Solução da Fase 2
Solução da Fase 2
Solução da Fase 2
Solução da Fase 2
Solução da Fase 2
Solução da Fase 2
Solução da Fase 2
Solução da Fase 2
Solução da Fase 2
• A solução ótima encontrada resulta em 11 caixas e 4 caixas eletrônicos

Genoa Curso Avançado AnyLogic PDF

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Genoa Curso Avançado AnyLogic PDF

Enviado por

Direitos autorais:

Formatos disponíveis

Treinamento Avançado

Esta apresentação faz parte do Treinamento

Programação estruturada x orientada a objetos

Programação orientada a objetos

O que é uma classe?

• Exemplo: implementação de uma calculadora

•Exemplo: definir uma rota para transferência de carga

Java: uma breve história

Java: uma breve história

O quanto Java é utilizado hoje?

Java Virtual Machine

5 % 2 ≡ 1? “Any” + “Logic” ≡ “AnyLogic”

5 / 2 ≡ 2? Let x = 14.3, then:

Calling functions and accessing fields

• Accessing object fields and functions

• Agent population is a collection.

̶ Is used in the conditions of limited knowledge mode

about the stochastic variable, namely we know the

Decision operator (if … else)

• Full form (if … else):

In case “if" or "else" code sections contain

for ( Person p : people )

for (Truck t : fleet)

Writing comments in Java code

// text An end-of-line comment: all the text from the ASCII

// Prepare Engine for simulation:

traceln("cenario: " + cenario);

Especificador Conversão aplicada

• No exemplo acima, teremos b = 3

• Situação prática: um agente do tipo Car

1. Nas propriedades da porta por onde

Para fazer isso, basta

Self Refere-se ao bloco onde está sendo chamado

Dinâmica de Sistemas (DS)

Dinâmica de Sistemas: estoques

Dinâmica de Sistemas: fluxos

Dinâmica de Sistemas: loops de retorno

Dinâmica de Sistemas: funções

Dinâmica de Sistemas: funções

Dinâmica de Sistemas: funções

trend(input, averageTime, initialTrend) retorna a taxa de crescimento fracionária média (negativa

Schedule programático – Fase 0

Schedule programático – Fase 0

Schedule programático – Fase 1 – Passo 1

Schedule programático – Fase 1 – Passo 2

• No corpo desta função iremos criar e inicializar o schedule

Schedule programático – Fase 1

Schedule programático – Fase 1 – Passo 3

Schedule mySchedule = new Schedule<Integer>(); //schedule vazio

Schedule programático – Fase 1

Schedule programático – Fase 1 – Passo 4

• Analogamente, adicione os outros dois intervalos, construindo um schedule idêntico àquele

Schedule programático – Fase 1 – Passo 4

Schedule programático – Fase 1 – Passo 5

Schedule programático – Fase 1 – Rodando o modelo

Schedule programático – Fase 2

Schedule programático – Fase 2 – Passo 1

Schedule programático – Fase 2 – Passo 2

Schedule programático – Fase 2 – Passo 3

Schedule programático – Fase 2 – Passo 4

• Este auxiliar gera um código base, que deve ser usado

Schedule programático – Fase 2 – Passo 4

Schedule programático – Fase 2 – Passo 5