Como usar o site

Simulacrum — referência rápida (schema v1/v2)
============================================

Blocos do fluxo (vocabulário em português, espelhando o Arena):

  chegada    (Create)  — gera entidades. Campos: nome, entidade,
             intervalo (distribuição), destino (opcional).
             Na v1, deve ser o 1º bloco do fluxo (e o único 'chegada');
             na v2, pode haver várias 'chegada' em qualquer posição.
  processo   (Process) — toma recurso, demora, libera (fila FIFO).
             Campos: nome, recurso, duracao (distribuição), destino.
  decisao    (Decide)  — desvia o fluxo. Campos: nome, ramos.
             Por chance:   - {percentual: 30, destino: x}   (somam 100)
             Por condição: - {se: 'prioridade >= 2', destino: x}
                           - {senao: y}    (último ramo, obrigatório)
  atribuir   (Assign)  — define atributos da entidade ou variáveis globais.
             Campos: nome, atribuicoes, destino.
             - {atributo: vip, valor: 1}
             - {variavel: total, valor: total + 1}
  registrar  (Record)  — conta ocorrências ou registra uma expressão.
             Campos: nome, tipo (contagem|expressao), expressao, destino.
             Ex.: {nome: mede, expressao: agora - chegada}
  saida      (Dispose) — remove a entidade e consolida estatísticas.

E/S de dados (ReadWrite do Arena — schema v2; só roda na CLI/MCP, local;
o site do aluno REJEITA modelos com 'arquivos:'):
  ler        (ReadWrite leitura) — lê a próxima linha de um CSV (em
             'arquivos:') para atributos da entidade. Campos: nome, arquivo
             (nome em 'arquivos:'), colunas ([atributo...], 1 por coluna
             lida), destino. Ao fim do arquivo: 'ciclar' (volta à 1ª linha)
             ou 'parar' (a entidade encerra ali, sem erro).
  escrever   (ReadWrite escrita) — grava uma linha num CSV de saída (em
             'arquivos:') com o valor de cada expressão. Campos: nome,
             arquivo, valores ([expressão...]), destino.

Blocos de transporte (schema v2 — Advanced Transfer do Arena):
  estacao    (Station/Enter) — ponto de entrada numa estação nomeada.
             Campos: nome, estacao (nome em 'estacoes:'), destino.
  transferir (Leave/Route/Transport/Convey) — move a entidade para uma
             estação. Campos: nome, para (estação alvo), modo
             (conectar|rota|transportador|esteira|sequencia), duracao (se rota),
             transportador (se transportador), esteira (se esteira).
             'conectar' = instantâneo; 'rota' = viagem por tempo;
             'transportador' = recurso móvel que busca a entidade
             (deslocamento vazio) e a leva (distância / velocidade);
             'esteira' = transporte contínuo por células (comprimento /
             velocidade).
  escolher_estacao (PickStation) — escolhe dinamicamente a estação destino
             entre 'opcoes' por uma 'regra' e roteia a entidade para lá.
             Campos: nome, regra, opcoes ([estação...]), criterio (se
             regra=expressao). Regras: menor_fila (vai p/ a cabine de menor
             fila), ciclico (rodízio), aleatorio (sorteio), expressao
             (índice 1-based do 'criterio'), menor_distancia (vai p/ a estação
             mais próxima da estação atual, pela matriz 'distancias:').
  sequencias (Sequence — objeto de dados) — roteiro fixo e ordenado de
             estações que a entidade percorre sozinha. Top-level 'sequencias:'
             = nome -> lista de paradas; cada parada tem 'estacao' e um
             'atribuir' opcional (atributo -> valor, aplicado ao chegar). A
             entidade entra no roteiro por 'sequencia:' na chegada; o bloco
             'transferir' com 'modo: sequencia' a leva a cada próxima parada
             (aplica as atribuições da parada e avança o cursor 'passo'). No
             fim do roteiro segue o 'destino:' do transferir.

Processo decomposto (schema v2 — Advanced Process do Arena):
  tomar      (Seize)   — aloca 1 unidade de um recurso, que PERSISTE entre
             blocos até um 'liberar'. Forma fila FIFO no recurso.
             Campos: nome, recurso, destino.
  atrasar    (Delay)   — espera uma duração sem alocar recurso.
             Campos: nome, duracao (distribuição), destino.
  liberar    (Release) — devolve um recurso tomado antes com 'tomar'.
             Campos: nome, recurso, destino.
  (tomar + atrasar + liberar equivale ao bloco 'processo' monolítico.)

Hold/Signal (schema v2 — Hold/Signal do Arena):
  reter      (Hold)    — prende a entidade numa fila até um 'sinalizar' do
             mesmo sinal liberá-la. Campos: nome, sinal, destino. O tempo
             preso conta no tempo de sistema (W), não na fila de serviço (Wq).
  sinalizar  (Signal)  — libera as entidades presas num sinal (todas, ou uma
             'quantidade', em ordem de chegada). Campos: nome, sinal,
             quantidade (opcional), destino. Todo sinal retido precisa de ao
             menos um 'sinalizar'. Exige versao: 2.

Batch/Separate (schema v2 — Batch/Separate do Arena):
  agrupar    (Batch)    — junta 'tamanho' entidades num LOTE (uma entidade
             representante). Campos: nome, tamanho (inteiro >= 2), tipo
             (temporario|permanente; default temporario), destino. Lote
             'temporario' pode ser reconstituído depois por um 'separar';
             'permanente' funde de vez (os membros somem). As entidades
             esperam o lote completar — esse tempo conta no tempo de sistema
             (W), não na fila de serviço (Wq).
  separar    (Separate) — desfaz um lote TEMPORÁRIO, devolvendo os membros
             originais (em ordem de chegada) ao fluxo. Campos: nome, destino.
             Só atua sobre lote temporário (separar em cópias = backlog).
             Exige versao: 2.
             Obs.: a fila do lote num recurso entre 'agrupar' e 'separar' conta
             no W de cada membro, não no Wq agregado (o lote temporário se
             desfaz no 'separar' e não chega à saída). Um lote PERMANENTE, que
             chega à saída, contribui a fila dele para o Wq normalmente.

Sincronização (schema v2 — Match do Arena):
  sincronizar (Match)   — segura entidades de tipos diferentes e libera UMA de
             cada tipo junta, no mesmo instante, quando o casamento completa.
             Campos: nome, entradas (lista de >= 2 tipos de 'entidade' vindos
             das chegadas), destino. As entidades seguem SEPARADAS após casar;
             para fundi-las num produto único, encadeie um 'agrupar' logo em
             seguida (receita de montagem). O tempo esperando o par conta no
             tempo de sistema (W). Exige versao: 2.

Transporte de carga (schema v2 — Pickup/Dropoff do Arena):
  aguardar_embarque   — a entidade PARA num ponto de embarque e espera um
             veículo recolhê-la. Campos: nome, embarque (nome do canal/ponto,
             compartilhado com 'carregar'). Não tem 'destino:' — a entidade só
             volta a andar quando descarregada. Não pode embarcar segurando um
             recurso (libere com 'liberar' antes). Exige versao: 2.
  carregar (Pickup)   — um veículo recolhe até 'quantidade' entidades que
             aguardam no ponto 'embarque' (FIFO) e as leva consigo. Campos:
             nome, embarque, quantidade (inteiro >= 1), destino (para onde o
             VEÍCULO segue). Exige versao: 2.
  descarregar (Dropoff) — o veículo larga TODA a carga que está carregando.
             Campos: nome, destino_carga (para onde a CARGA solta vai),
             destino (para onde o VEÍCULO segue). O tempo que o passageiro
             passou embarcado conta no seu tempo de sistema (W). Exige versao: 2.

Lógica de fila (schema v2 — Search/Remove do Arena):
  procurar (Search) — uma entidade varre a fila de espera de um 'reter' e acha
             a PRIMEIRA (ordem de chegada) que satisfaz um critério. Campos:
             nome, fila (o mesmo nome do 'sinal:' do 'reter'), condicao
             (expressão booleana sobre os ATRIBUTOS de cada entidade parada,
             ex.: "prioridade >= 2"), resultado (opcional: atributo onde grava
             o rank 1-based do achado, 0 se nada), destino (para onde a
             buscadora segue). Para comparar com um valor da própria buscadora,
             grave-o antes numa VARIÁVEL global com 'atribuir'. Exige versao: 2.
  remover (Remove) — retira da fila a entidade achada pelo 'procurar' anterior e
             a encaminha. Campos: nome, fila (a mesma do 'procurar'),
             destino_removido (para onde a entidade RETIRADA vai),
             destino (para onde a buscadora segue). Sem um achado válido, é
             no-op (não remove ninguém e segue). Cada 'remover' deve ser
             precedido por um 'procurar' no MESMO caminho da entidade — ele
             reutiliza o último achado dela (um achado por vez). Exige versao: 2.

Área de armazenamento / WIP (schema v2 — Store/Unstore do Arena):
  armazenar (Store) — a entidade ENTRA numa área nomeada e SEGUE o fluxo (não
             bloqueia). Campos: nome, armazem (o nome da área), destino (para
             onde a entidade segue). Exige versao: 2.
  desarmazenar (Unstore) — a entidade SAI da área (não bloqueia). Campos: nome,
             armazem (a mesma de um 'armazenar'), destino. Exige versao: 2.
  A corrida reporta, por área, o número MÉDIO no tempo e o MÁXIMO de entidades
  simultâneas dentro dela (estatística time-persistent / WIP). Toda entidade
  precisa 'desarmazenar' antes da 'saida'. Dica: armazene logo após a 'chegada'
  e desarmazene antes da 'saida' para medir o WIP do sistema inteiro — o médio
  é L (Lei de Little).

Elementos de apoio v2:
  estacoes:  {nome: {}}   — locais nomeados
  transportadores: {nome: {unidades: N, velocidade: v, inicio: estacao}}
             — recursos móveis (Transporter); tempo = distância / velocidade,
             com deslocamento vazio até a entidade.
  distancias: [{de: estacao, para: estacao, distancia: d}, ...]
             — matriz simétrica entre estações (Distance). Precisa cobrir
             todo par que 'menor_distancia' ou 'transferir' por
             transportador possam precisar medir — faltando o par, o erro
             em runtime é "Falta a distância…".
  esteiras:  {nome: {velocidade: v, celula: c, tipo: acumulativa|nao_acumulativa}}
             — transporte contínuo (Conveyor); nº de células = comprimento
             total / c; tempo = comprimento do segmento / v. 'acumulativa' =
             peças podem acumular; 'nao_acumulativa' = espaçamento rígido na
             entrada (uma a cada c/v). Default: acumulativa.
  segmentos: [{esteira: nome, de: estacao, para: estacao, comprimento: d}, ...]
             — trechos de uma esteira entre estações (Segment), simétricos.
             Cada segmento mede ao menos uma célula.
  Múltiplas 'chegada' são permitidas em 'versao: 2'.

Elementos de apoio (nível raiz do YAML):
  recursos:    {nome: {capacidade: N}}   — N >= 1 servidores. Opcional:
               'horario' (Schedule do Arena) = lista cíclica de fases
               {duracao, capacidade} que faz a capacidade VARIAR no tempo
               (ex.: fechar no almoço com capacidade 0). A 'capacidade:' do
               recurso é o PICO (máximo); cada fase só reduz a partir dela.
               Quem está em serviço termina; nenhum atendimento novo começa
               enquanto a capacidade estiver reduzida. Exige versao: 2. A
               utilização é relativa ao pico no horizonte inteiro.
               Também opcional: 'falha' (Resource Failure do Arena) = quebra
               estocástica do recurso. Campos: mtbf (distribuição do tempo
               entre falhas), mttr (distribuição do tempo de reparo),
               unidades (opcional; quantas unidades caem por falha, default
               = capacidade de pico), regra (opcional; só 'ignore' por
               enquanto — quem está em serviço termina, nenhum atendimento
               novo começa nas unidades caídas; 'preempt' é incremento
               futuro). 'mtbf'/'mttr' multi-arg precisam de aspas simples
               (ex.: 'tria(2,5,10)'). Exige versao: 2. Um recurso não pode
               ter 'horario' e 'falha' ao mesmo tempo. A disponibilidade
               A = MTBF/(MTBF+MTTR) é um limite superior natural da
               utilização do recurso.
  conjuntos:   {nome: [recurso1, recurso2, ...]}   — conjunto de recursos
               (Set do Arena). Um bloco 'processo'/'tomar' pode usar
               'conjunto: <nome>' no lugar de 'recurso:', com 'regra:' de
               seleção do membro (ciclico=rodízio | aleatorio | menor_fila=vai
               para o de menor fila de espera; default ciclico). 'liberar'
               usa o mesmo 'conjunto:' e devolve o membro que a entidade
               pegou. Os membros precisam ser recursos declarados; o nome
               do conjunto não pode colidir com um recurso. Exige versao: 2.
  atributos:   {nome: valor_inicial}     — por entidade
  variaveis:   {nome: valor_inicial}     — globais
  arquivos:    {nome: {caminho: <relativo>, ao_fim: ciclar|parar}}
               — arquivos CSV usados por 'ler'/'escrever' (ReadWrite do
               Arena). 'caminho' é relativo à pasta do modelo (sem '..',
               sem drive, sem barra inicial). 'ao_fim' só importa para
               leitura (default 'ciclar'). E/S de arquivo roda na
               CLI/MCP (local), não no site do aluno.
  experimento: horizonte, aquecimento, replicacoes, semente

Nomes automáticos em expressões: agora (relógio simulado) e chegada
(instante de criação da entidade) — não podem ser declarados.

Distribuições (strings): expo(media), const(valor), unif(min,max),
norm(media,dp), tria(min,moda,max), erlang(k,media), weibull(forma,escala).

Fluxo: por padrão a entidade segue para o PRÓXIMO bloco da lista;
'destino: nome_do_bloco' redireciona (o fluxo é um grafo). Toda entidade
precisa alcançar um bloco 'saida'.