Arena®

GUIA DO DESENVOLVEDOR DE
MODELOS
PUBLICAÇÃO ARENDG-RM001G-PT-P – janeiro 2012
Substitui a publicação ARENDG-RM001F-PT-P
PN-111652
 Contato Telefone de Suporte ao Cliente da Rockwell Automation - 1.440.646.3434
Suporte on-line - http://www.rockwellautomation.com/support/

Aviso de direitos autorais © 2012 Rockwell Automation, Inc. Todos os direitos reservados.
Impresso nos EUA.
Este documento e quaisquer produtos da Rockwell Software que os acompanham são protegidos por direitos autorais da
Rockwell Automation, Inc. Qualquer reprodução e / ou distribuição sem o consentimento prévio por escrito da
Rockwell Automation, Inc. é estritamente proibida. Consulte o contrato de licença para obter detalhes.
Avisos sobre marcas comerciais Arena, Rockwell Automation e SIMAN são marcas registradas da Rockwell Automation, Inc.

Outras marcas comerciais ActiveX, Microsoft, Microsoft Access, SQL Server, Visual Basic, Visual C ++, Visual SourceSafe, Windows,
Windows ME, Windows NT, Windows 2000, Windows Server 2003, Windows Vista e Windows XP são marcas
registradas ou comerciais da Microsoft Corporation em Estados Unidos e / ou outros países.
Adobe, Acrobat e Reader são marcas registradas ou comerciais da Adobe Systems Incorporated nos Estados
Unidos e / ou em outros países.
ControlNet é uma marca registrada da ControlNet International.
DeviceNet é uma marca comercial da Open DeviceNet Vendor Association, Inc. (ODVA)
Ethernet é uma marca registrada da Digital Equipment Corporation, Intel e Xerox Corporation
OLE for Process Control (OPC) é uma marca registrada da OPC Foundation.
Oracle, SQL * Net e SQL * Plus são marcas registradas da Oracle Corporation.
Todas as outras marcas comerciais são de propriedade de seus respectivos proprietários e são aqui reconhecidas.
garantia Este produto é garantido de acordo com a licença do produto. O desempenho do produto pode ser afetado pela
configuração do sistema, pelo aplicativo sendo executado, pelo controle do operador, pela manutenção e por outros
fatores relacionados. A Rockwell Automation não é responsável por esses fatores intervenientes. As instruções neste
documento não cobrem todos os detalhes ou variações do equipamento, procedimento ou processo descrito, nem
fornecem instruções para atender a todas as contingências possíveis durante a instalação, operação ou manutenção. A
implementação deste produto pode variar entre os usuários.
Este documento é atualizado a partir do momento do lançamento do produto; no entanto, o software que acompanha o
produto pode ter sido alterado desde o lançamento. A Rockwell Automation, Inc. reserva-se o direito de alterar
qualquer informação contida neste documento ou no software a qualquer momento, sem aviso prévio. É de sua
responsabilidade obter as informações mais atuais disponíveis da Rockwell ao instalar ou usar este produto.

Versão: 14.00.00
Modificado: 18 de janeiro de 2012 9:32:31

vi
Conteúdo

1 • Bem-vinda 11
O que é o software de simulação Arena?......................................................................1 1
Audiência pretendida.......................................................................................................2
Sobre este guia................................................................................................................2
Onde posso pedir ajuda?..................................................................................................3
Consulte os guias do usuário....................................................................................3
Explore nossos exemplos.........................................................................................3
Obter ajuda...............................................................................................................3
Use a biblioteca Smarts............................................................................................3
Obter suporte por telefone.......................................................................................4
Obter suporte da Web..............................................................................................4
Consulte o site da Arena..........................................................................................5
Obter treinamento....................................................................................................5
Obter serviços de consultoria...................................................................................5
Contate-Nos.............................................................................................................5

2 • Visão geral do desenvolvimento de modelos de arena 7

Modelagem com Arena - uma visão geral.......................................................................7
Modelos e painéis............................................................................................................9
Definições e instâncias do módulo................................................................................10
Definindo um módulo...................................................................................................11
Ícone do painel.......................................................................................................13
Visualização do usuário.........................................................................................14
Design e operandos da caixa de diálogo................................................................15
Lógica....................................................................................................................17
Comuta...................................................................................................................20
Elementos e propriedades..............................................................................................22
Hierarquia da arena e SIMAN.......................................................................................23
Fluxogramas e módulos de dados..................................................................................25
Uso de modelos.............................................................................................................25
Introdução..............................................................................................................25
Ferramentas gerais de modelagem.........................................................................25
Ambientes orientados para a indústria...................................................................26
Ferramentas focadas em aplicativos......................................................................26
Melhorando a produtividade da modelagem e compartilhando a tecnologia de
modelagem.............................................................................................................27

3
UMARENA TEMPLATE DEVELOPER"S
GUIDE

3 • Tutorial de criação de módulos 29

Visão geral do módulo..................................................................................................29
Introdução - Um novo modelo.....................................................................................32.
Design de Diálogo.........................................................................................................33
A janela de design da caixa de diálogo..................................................................33
Adicionando operandos da caixa de diálogo do módulo........................................35
Adicionando operandos do ponto de entrada / saída do módulo...........................37.
Organizando o layout do formulário de Diálogo..................................................39.
Lógica...........................................................................................................................40.
A janela lógica......................................................................................................40.
Visão geral da lógica do módulo da impressora...................................................41.
Entidades receptoras e apreendendo a impressora - os módulos Fila e apreensão 42.
Decidir se deseja trocar a impressora - O módulo Decide.....................................44
Lógica de mudança - Atribuir, processar e atribuir módulos.................................45
A lógica de impressão - Módulos de atraso e liberação........................................48.
Definindo os elementos do módulo Impressora - elementos Filas e Variáveis.....50.
Visualização do Usuário................................................................................................53
Ícone do painel.............................................................................................................56.
Um modelo de amostra..................................................................................................57
Preparando o modelo para uso...............................................................................57
Modelo de simulação de impressora única............................................................58
Sumário.........................................................................................................................64

4 • A janela Modelo 65
O menu do modelo........................................................................................................65
Criando uma nova janela de modelo......................................................................65
Carregando um arquivo de painel de modelo existente........................................66.
Fechando um modelo............................................................................................66.
Salvando o arquivo de biblioteca do painel de modelos.......................................66.
Criando e editando módulos.........................................................................................66.
A lista de definições do módulo............................................................................66.
Abrindo Janelas de Definição do Módulo..............................................................67
Preparando o painel de modelos para uso......................................................................67
Verificando se há erros e avisos no painel de modelos..........................................67
Analisando erros....................................................................................................68
Relatórios de arquivo do painel Modelo................................................................68
Gerando o arquivo de objeto do painel de modelo (.tpo).......................................71
Outras informações do painel de modelos.....................................................................71
Alterando a versão.................................................................................................71
Opções de modelo..................................................................................................71
Definindo Módulos Necessários............................................................................73
Definindo Módulos de Dados................................................................................74
 Definindo um operando de nome...........................................................................74
Definições do Construtor de Expressões................................................................75
Criando cópias das definições do módulo..............................................................75
Compatibilidade de instâncias de módulos existentes...........................................75

5 • A janela Design do diálogo 77

Visão geral da janela Design do diálogo.......................................................................77
O Operand Explorer...............................................................................................78
A caixa de ferramentas..........................................................................................80
O formulário da caixa de diálogo...........................................................................82
A grade Propriedades de design.............................................................................83
Usando os controles da caixa de ferramentas................................................................84
Usando o controle de texto....................................................................................84
Usando o controle GroupBox................................................................................85
Usando o controle de linha....................................................................................85
Usando o controle TextBox...................................................................................85
Usando o controle ComboBox...............................................................................85
Usando o controle RadioButtonGroup...................................................................86
Usando o controle CheckBox................................................................................87
Usando o controle DialogButton............................................................................87
Usando o controle RepeatGroupDialog.................................................................87
Usando o controle RepeatGroupTable...................................................................88
Usando o controle DateTimePicker.......................................................................88
Usando o controle DatePicker................................................................................89
Usando o controle TimePicker...............................................................................90
Usando o controle FilePicker.................................................................................90
Usando o controle HiddenOperand........................................................................91
Usando operandos.........................................................................................................91
Especificando a propriedade Nome.......................................................................91
Especificando a propriedade LogicProperties........................................................92
Especificando a propriedade Value........................................................................97
Especificando a propriedade DataType...............................................................101
Especificando a propriedade SwitchName...........................................................102
Especificando a propriedade InUserView............................................................103
Operandos ocultos................................................................................................103
Usando grupos de repetição.........................................................................................103
Especificando a propriedade Nome.....................................................................103
Especificando a propriedade LogicProperties......................................................104
Repita a profundidade da definição do grupo e as regras de referência...............105
Acessando o número de tuplas e o número da tupla............................................107
Combinando valores repetidos de operando em um único valor..........................107
Usando módulos repetíveis na janela lógica com grupos de repetição................109
 Usando teclas aceleradoras..........................................................................................109
Barra de ferramentas Design da caixa de diálogo........................................................110

6 • A janela lógica 111

Lógica de simulação e design de módulos..................................................................111
A janela lógica.....................................................................................................112
Diferenças entre janelas lógicas e modelo...................................................................113
Executando modelos de simulação (janela de modelo)........................................113
Operandos de referência (janela lógica)...............................................................114
Alternando instâncias do módulo (janela lógica).................................................114
Definindo lógica repetível....................................................................................114
Conexões do módulo na janela lógica..................................................................115
Anexando painéis de modelo enquanto trabalhava em uma janela lógica...........115
Exibição de objetos de animação (janela lógica).................................................115
Campos e operandos............................................................................................116
Referenciando Dados do Módulo................................................................................116
Operandos de referência......................................................................................116
Acesso especial para caixas de seleção, grupos de botões de opção e caixas de
combinação..........................................................................................................123
Comutadores nas instâncias do módulo da janela lógica.....................................124
Definindo a transferência de entidades para dentro e fora de um módulo...........125
Referenciando Operandos Não Repetitivos de um Grupo Repetitivo..................129
Referenciando Operandos Repetitivos.................................................................131
Definindo pontos de saída repetíveis em um módulo..........................................136
Módulos repetíveis...............................................................................................139
Exemplo 1: Lógica Paralela.................................................................................141
Exemplo 2: Lógica serial.....................................................................................143
Exemplo 3: Definindo Saídas Alternativas..........................................................145
Opções personalizadas usando os botões de opção e controles da caixa de seleção
.............................................................................................................................147
Conexões do módulo...................................................................................................148
Usando conexões gráficas....................................................................................148
Definindo várias conexões a partir de um único ponto de saída..........................148
Repetindo pontos de saída na janela lógica..........................................................149
Alternando instâncias do módulo................................................................................152
Conectando e Desconectando Interruptores.........................................................153
Efeito de comutadores na janela lógica................................................................154
Usando os módulos utilitários da Arena (de utlarena.tpo)...................................156
Definindo Rastreio de Módulo....................................................................................160
Regras e diretrizes de definição de lógica...................................................................161
7 • A janela de exibição do usuário 163
Instâncias do módulo...................................................................................................164
Objetos relacionados ao módulo.................................................................................164
A alça do módulo.................................................................................................165
A caixa de diálogo Module Text Options............................................................165
Pontos de entrada e saída.....................................................................................166
Operandos exibidos..............................................................................................167
Desenhar objetos.........................................................................................................170
Objetos de animação...................................................................................................170
Uso da chave User View.............................................................................................173

8 • A janela do switch 175

Definindo opções.........................................................................................................176
Mudar nomes.......................................................................................................177
Alternar definições......................................................................................................177
Regras de definição de switch.....................................................................................179

9 • A janela de ícone do painel 181

Criando o ícone do painel............................................................................................182

10 • Elementos 183
Definindo elementos em módulos...............................................................................185
Criando elementos...............................................................................................185
Listas de elementos..............................................................................................186
Propriedades........................................................................................................187
Uso de elementos e propriedades nas definições de módulo.......................................187
Acesso às propriedades em um modelo...............................................................188
Exibindo listas de elementos................................................................................188
Definindo elementos da hierarquia..............................................................................190
Operandos do elemento...............................................................................................190
Definindo Operandos do Elemento......................................................................190
Sublistas...............................................................................................................192
Definindo e referenciando elementos...................................................................193
Operandos de propriedade...........................................................................................194
Definindo operandos de propriedades..................................................................194
Definindo propriedades repetidas........................................................................195
Definindo um elemento ou propriedade usando um operando oculto..................199
Interruptores e elementos............................................................................................202
 Tipos de elementos especiais.......................................................................................203
Elementos de comprimento fixo..........................................................................204
Lista de elementos ocultos...................................................................................204
Elementos invertidos............................................................................................206

A • Diretrizes de design do modelo 211

Design da caixa de diálogo (janela de design da caixa de diálogo).............................211
Caixa de diálogo..................................................................................................211
Objetos de operando............................................................................................211
Dicas úteis para definir objetos na janela de design da caixa de diálogo.............212
Geral....................................................................................................................212
Ícone do painel............................................................................................................213
Visualização do usuário...............................................................................................213
Lógica do módulo........................................................................................................214
Convenções de nomenclatura......................................................................................214
Documentação do modelo...........................................................................................214
Vestígio.......................................................................................................................215
Estatísticas e relatórios................................................................................................215

B • Mesas 217
Elementos e propriedades............................................................................................217
Elementos padrão.................................................................................................217
Elementos invertidos............................................................................................237
Elementos de comprimento fixo..........................................................................239
Tipos de dados.............................................................................................................264
Definições de tipo de dados.................................................................................264
Tipos de dados do ponto de conexão e blocos SIMAN...............................................275
Tipos de pontos de entrada ou saída....................................................................275

C • Criando arquivos de ajuda online 277

Índice 281

viii
11 Bem-vinda
O que é o software de simulação Arena?
O Arena® é um sistema de simulação avançado que fornece um ambiente interativo
para criar, animar, verificar e analisar modelos de simulação. Com o Arena, você
pode criar um modelo exclusivo do Arena específico para seu projeto, empresa ou
setor. Os recursos de desenvolvimento de modelos se baseiam na estrutura
hierárquica natural do Arena, permitindo que você crie novas ferramentas de
simulação em um ambiente gráfico e fácil de usar.
Na área de criação de modelos da Arena, você cria blocos de construção de
simulação completos, chamados módulos. Esses módulos podem ser muito simples,
como um que conta os clientes quando eles saem de um banco. Ou você pode criar
um módulo altamente complexo que capture todas as atividades em uma doca do
estaleiro. De fato, a hierarquia da Arena o encoraja a desmontar os sistemas
estudados em seus elementos básicos críticos, e depois combinar esses elementos
básicos nos componentes e subsistemas mais complexos a serem simulados.
Os módulos que você constrói são coletados em bibliotecas, conhecidas como
modelos. Você pode usar esses modelos para apoiar suas próprias atividades de
simulação ou compartilhar essas ferramentas de simulação com outros modeladores.
Ao incentivar esse compartilhamento de tecnologia, a Arena oferece a oportunidade
de você, como modelador de simulação, criar ambientes completamente
personalizados, sem escrever nenhum código de programação. Os modeladores
iniciantes podem acessar o poder da simulação como uma ferramenta de suporte à
decisão trabalhando com terminologia, lógica de modelagem e animação gráfica
especialmente desenvolvidas para suas necessidades. Modeladores de simulação
experientes podem melhorar sua produtividade e compartilhar o conhecimento que
adquirem capturando a lógica de simulação essencial e empacotando-a rapidamente
em um bloco de construção reutilizável e verificado para modelos futuros.
Como já mencionado, no Arena você tem a capacidade de definir novas
construções de modelagem, chamadas módulos, e armazená-las em bibliotecas,
conhecidas como AST (Application Solution Templates) ou modelos.
Se você estiver familiarizado com o ambiente de construção e análise de modelos da
Arena, descobrirá que os recursos de desenvolvimento de modelos se baseiam nos
conceitos e na interface que você já aprendeu. Para trabalhar com modelos, ao
executar o Arena, você abrirá uma Janela de Modelo em vez de uma Janela de
Modelo. Selecione a opção de menu Arquivo> Novo ou
 1 • WELCOME

pressione o botão da barra de ferramentas Novo arquivo. Na caixa de diálogo

exibida, selecione Template Window e clique em OK, como mostra a Figura 1.1.

Figura 1.1 Seleção da janela de modelo da Arena

Essa janela de modelo serve como uma "base" para as atividades envolvidas na
construção de um modelo. As janelas com as quais você trabalha para definir os
módulos são exibidas na mesma área de trabalho que as janelas do modelo Arena,
entrada e saída. Você interage com essas janelas usando a interface de usuário
padrão do Arena.

Audiência pretendida
Antes de começar a criar modelos, você já deve ter um bom entendimento da
interface básica de modelagem da Arena e do modelo SIMAN ou dos modelos de
Processo Básico, Processo Avançado e Transferência Avançada da Arena. Este guia
pressupõe que você esteja familiarizado com os conceitos e terminologia de
modelagem do Arena, apresentados no Guia do usuário e na Ajuda do Arena.

Sobre este guia

O Guia do Desenvolvedor de Modelos de Arena foi desenvolvido para servir como
um manual de instruções para criação de modelos e como um guia de referência para
os recursos de criação de modelos. Os dois primeiros capítulos familiarizam você
com os conceitos e terminologia empregados no Arena e mostram um tutorial de
construção de módulos. A inscrição da janela do modelo segue e, em seguida, de
cada uma das cinco janelas que você usa para criar módulos. A seguir, apresentamos
o Elements, o conceito final relacionado à definição dos módulos da Arena. O
apêndice B deste livro contém tabelas de referência.
Antes de começar a trabalhar com os recursos de criação de modelos,
recomendamos que você leia o Capítulo 2, “Visão geral do desenvolvimento de
modelos de arena”, para se familiarizar com os conceitos e terminologia do Arena.
Em seguida, siga as instruções passo a passo fornecidas no tutorial de construção
de módulos no Capítulo 3. Enquanto estiver construindo seu primeiro módulo,

2
 1 • WELCOME
convém ver os conceitos apresentados no Capítulo 2.

3
Onde posso pedir
ajuda?
Nosso compromisso com o seu sucesso começa com o conjunto de material didático
e assistência que fornecemos para a Arena.

Consulte os guias do usuário

O conjunto de documentação inclui este manual, o Arena Template Developer's
Guide, que apresenta a criação de modelos e a construção de módulos. Além disso,
o Guia do usuário do Arena e o Guia de variáveis são manuais de referência
separados que fornecem informações sobre módulos de modelagem nos painéis
Processo básico, Processo avançado, Transferência avançada e Processo de fluxo,
além de descrições completas das variáveis do Arena encontradas em os modelos de
produtos da Arena.
CONVENÇÕES DE DOCUMENTOS
Ao longo dos guias, várias convenções de estilo são usadas para ajudar a identificar o
material. Novos termos e conceitos podem ser enfatizados pelo uso de itálico ou
negrito; os caminhos do menu de arquivo estão em negrito com um (>) separando as
entradas (por exemplo, vá para Ajuda> Ajuda da Arena); o texto que você deve digitar
é mostrado em Courier Bold (por exemplo, neste campo, digite Semana de Trabalho)
e os nomes dos botões da caixa de diálogo e da janela são mostrados em negrito (por
exemplo, clique em OK).

Explore nossos exemplos

O Arena é acompanhado por vários modelos de exemplo que ilustram muitas das
abordagens comumente usadas para capturar a essência de uma variedade de
processos. São fornecidos exemplos para os ambientes de job shop e flow shop. Para
obter uma lista dos exemplos da Arena, vá para Ajuda> Ajuda da Arena. Na guia
Conteúdo, escolha Noções básicas de construção de modelo e selecione Exibindo
modelos de exemplo da arena.

Obter ajuda
A ajuda está sempre ao seu alcance! O Arena incorpora os mais recentes recursos de
ajuda, incluindo O que é isto? ajuda que exibe uma breve descrição dos campos nas
caixas de diálogo, ajuda contextual nos botões do menu e da barra de ferramentas e
um botão de ajuda em cada um dos módulos do Arena. Consulte o índice e o índice
da Ajuda da Arena para obter uma lista de todos os tópicos da ajuda.

Use a biblioteca Smarts

Ao criar modelos de seus próprios processos de fabricação, use nossa biblioteca
Smarts para explorar a melhor maneira de usar o Arena. Este conjunto de modelos
de tutoriais cobre tópicos que variam
de recursos de modelagem a técnicas de animação. A biblioteca está organizada em
categorias para ajudá-lo a encontrar o modelo certo. Quando você estiver se
perguntando como dar o próximo passo no seu modelo, procure na biblioteca
Smarts uma solução pronta. Para obter uma lista de categorias e seus Smarts
relacionados, vá para Ajuda> Ajuda da Arena. Na guia Conteúdo, primeiro clique
em Fundamentos da construção de modelo e, em seguida, Learning Arena com
arquivos inteligentes.

Obter suporte por telefone

A Rockwell Automation fornece suporte completo para toda a família de produtos
Arena. Perguntas relacionadas à instalação, como os módulos funcionam, o uso do
editor de modelos e o uso do software são tratadas pelo suporte técnico.
O SUPORTE TÉCNICO DA ARENA INCLUI:
 (para usuários em manutenção ativa), uma linha direta de suporte técnico e
endereço de e-mail com profissionais experientes em tempo integral
 ajuda com problemas de instalação ou perguntas relacionadas aos requisitos do
software
 solução de problemas
 suporte limitado em relação à interação do Arena com outros programas
 suporte do Arena Object Model, usado no Microsoft Visual Basic for
Applications.
Se você ligar para a linha de suporte (1.440.646.3434, opção 3 e 7), deve estar no
seu computador e estar preparado para fornecer as seguintes informações:
 o número de série do produto
 o número da versão do produto
 o sistema operacional que você está usando
 o texto exato de todas as mensagens que apareceram na tela
 uma descrição do que aconteceu e o que você estava fazendo quando o
problema ocorreu
 uma descrição de como você tentou resolver o problema.
O suporte técnico internacional é fornecido pelos representantes globais. Para obter
informações de contato do representante mais próximo de você, visite a página
Parceiros Globais emwww.ArenaSimulation.com.

Obter suporte da Web

Além do suporte por telefone, o Centro de Suporte ao Cliente da Rockwell
Automation oferece extensas bases de conhecimento on-line de notas técnicas e
perguntas freqüentes para suporte a problemas não urgentes. Esses bancos de dados
são atualizados diariamente por nossos especialistas em suporte. Vamos
parahttp://www.rockwellautomation.com/support/ para se inscrever no suporte
online.
Depois de se inscrever no suporte on-line, você pode optar por receber e-mails
regulares com links para as notas técnicas mais recentes, atualizações de software
e atualizações de firmware dos produtos que são do seu interesse. Você também
pode enviar solicitações de suporte online.
Se você não encontrar a resposta que precisa, entre em contato com o seu
representante local ou o suporte técnico da Arena.

Consulte o site da Arena

O site da Arena fornece uma coleção de breves vídeos de instruções e tópicos de
perguntas frequentes que podem ser úteis para você. Este material e muito mais
estão disponíveis na guia Ferramentas e recursos dowww.ArenaSimulation.com.

Obter treinamento
Você precisa de treinamento? A Rockwell Automation oferece um curso de
treinamento padrão, composto por palestras e workshops práticos, projetados para
apresentar os conceitos fundamentais da modelagem com o Arena.
Também oferecemos cursos de treinamento personalizados, projetados para atender
às suas necessidades específicas. Esses cursos podem ser realizados em nossos
escritórios ou nos seus e podemos acomodar uma pessoa ou vinte. Você cria o curso
certo para você! Entre em contato com nosso grupo de serviços de consultoria para
discutir como podemos ajudá-lo a obter sucesso em seus esforços de simulação.

Obter serviços de consultoria

A Rockwell Automation também fornece consultoria especializada e implementação
chave na mão de todo o conjunto de produtos Arena. Entre em contato com nossos
escritórios para obter mais informações.

Contate-Nos
Nós nos esforçamos para ajudar todos os nossos clientes a obterem sucesso em seus
esforços de melhoria de fabricação. Para esse objetivo, convidamos você a entrar
em contato com o seu representante local ou com a Rockwell Automation a
qualquer momento que possamos ajudá-lo. Certifique-se de se conectar conosco no
Facebook e participar do grupo de usuários da Arena no LinkedIn.
E-mail de suporte: Arena-
Support@ra.rockwell.com Telefone de suporte:
1.440.646.3434, opções 3 e 7 Email geral: Arena-
Info@ra.rockwell.com
Telefone de vendas nos EUA:
1.724.741.4000
URL:www.ArenaSimulation.com
URL: www.RockwellAutomation.com
2 Visão geral do
desenvolvimento de modelos
de arena
Neste capítulo, apresentamos os conceitos relacionados à criação de modelos
usando o Arena. Conforme descrito no Capítulo 1, o Arena fornece um ambiente
totalmente integrado para construção, animação, verificação e análise de modelos
de simulação. Isso é feito com a criação de componentes de modelagem
reutilizáveis chamados módulos que são coletados em bibliotecas ou modelos.
Para apresentá-lo à criação de modelos, começamos analisando o processo de
construção de modelos na Arena.

Modelagem com Arena - uma visão geral

No Arena, os modelos de simulação são construídos colocando os módulos em uma
janela de modelo, fornecendo dados para esses módulos e especificando o fluxo de
entidades através dos módulos. Um módulo define a lógica subjacente que é aplicada
quando uma entidade é direcionada ao módulo, bem como a animação gráfica
associada, para representar as atividades do módulo durante uma execução de
simulação. Esta seção fornece uma breve visão geral da construção de modelos com
o Arena. Para obter informações sobre como usar o Arena para criar, animar e
analisar modelos de simulação, consulte o Guia do Usuário e a Ajuda do Arena.
Para usar um módulo em um modelo Arena, um painel contendo o módulo é
anexado à Barra de Projetos. Este painel exibe todos os módulos que podem ser
selecionados para posicionamento no modelo. Para construir um modelo, selecione
um módulo no painel e coloque-o na janela do modelo. Os gráficos associados ao
módulo, referidos como sua visualização do usuário, são adicionados à janela do
modelo. Essa exibição do módulo sempre contém um identificador de módulo
(normalmente o nome do módulo) e pode incluir objetos de desenho estáticos,
objetos de animação, valores de exibição de operandos e pontos de conexão,
conforme ilustrado na Figura 2.1.

7
Figura 2.1 Visualização do usuário do módulo de processo

8
UMARENA TEMPLATE DEVELOPER"S
GUIDE

Depois que um módulo é colocado na janela do modelo, seus dados associados

podem ser editados clicando duas vezes no módulo. Essa ação abre a caixa de
diálogo principal do módulo, que normalmente contém um ou mais valores
alteráveis, chamados de operandos do módulo. Esses operandos fornecem os
mecanismos para alterar o comportamento do módulo em diferentes usos em
modelos de simulação. Por exemplo, usando o módulo Processo no painel Processo
Básico, você pode apreender, atrasar e liberar com um recurso chamado Line D
Labeler. No mesmo modelo, você pode colocar outro módulo Process que requer um
recurso chamado Line D Packer para processamento. As entidades enviadas ao
primeiro módulo aguardam o recurso Labeler da Linha D. Enquanto as entidades que
chegam ao segundo módulo Process passam por uma lógica semelhante (ou seja, a
lógica capturada no módulo Process),
Para definir o fluxo de entidades entre os módulos, é possível usar conexões diretas
ou transferências de estações. Uma conexão direta é formada colocando uma
conexão de um ponto de saída do módulo para um ponto de entrada do módulo. As
entidades que deixam um módulo através de um ponto de saída são transferidas
através da conexão ao ponto de entrada sem demora. Uma transferência de estação
ocorre quando uma entidade sai de um módulo por meio de uma rota, transporte ou
transporte, como visto nos módulos Sair ou Rota do painel Transferência Avançada;
nesses casos, um destino de estação é especificado e a entidade é enviada ao módulo
que define a estação, como um módulo Enter ou Estação (painel Transferência
avançada). Essas transferências de estação geralmente envolvem atrasos de tempo e
podem exigir um dispositivo de transferência de material (por exemplo, pessoa,
ônibus,
Depois que os módulos são colocados em um modelo e os valores são fornecidos
para seus operandos, uma execução de simulação pode ser realizada. Para iniciar
uma execução, o Arena gera um arquivo de modelo SIMAN (representando a lógica
do modelo) e um arquivo de experimento (contendo dados para suportar o modelo)
com base nos módulos que foram colocados no modelo Arena. Os valores dos
operandos do módulo podem fazer com que seções específicas do modelo sejam
geradas ou ignoradas, podem causar a criação de elementos no experimento e podem
ativar ou desativar a exibição de componentes de animação. Por exemplo, a coleta
de uma contagem no módulo Registro faz com que um bloco Contagem seja
incluído no arquivo de modelo SIMAN e um elemento Contadores listando o nome
do contador a ser gravado no arquivo experimental do SIMAN. Nesse caso, nenhum
componente de animação é incluído automaticamente.
 Modelos e painéis
Um modelo consiste em um painel ou um conjunto de painéis que abrange
construções de modelagem para um aplicativo, sistema, classe de sistemas ou
ambiente de destino geral específico. Um painel de modelos contém módulos
coletados em um arquivo e devem ser apresentados como um grupo independente.
Os painéis comumente usados para a modelagem padrão da Arena incluem:
Processo Básico, Processo Avançado e Transferência Avançada. Cada painel
consiste em construções de modelagem relacionadas; juntos, eles são documentados
e referidos como o modelo da Arena. Da mesma forma, o modelo SIMAN contém
dois painéis: Blocos e Elementos.
Os modeladores de arena anexam painéis de modelo à barra de projetos na janela do
aplicativo do ambiente de modelagem de arena. A Barra do projeto hospeda os
objetos principais usados para construir um modelo, portanto, o modelador
seleciona os módulos no painel Barra do projeto apropriado e os coloca na janela do
modelo. O arquivo de modelo anexado à Barra do Projeto é chamado de arquivo de
objeto do painel de modelos (ou arquivo .tpo). O painel exibe uma lista dos módulos
contidos no arquivo .tpo.
Ao desenvolver seu próprio modelo, você trabalha com um arquivo de biblioteca do
painel de modelos (ou
arquivo .tpl). Este arquivo contém as definições dos módulos no painel de modelos.
Os conceitos de definições e instâncias de módulos são discutidos na próxima seção.
Para trabalhar com um arquivo do painel de modelo, você pode criar um novo
arquivo selecionando o item de menu Arquivo> Novo no Arena e escolhendo a opção
Janela do modelo; ou use o item de menu Arquivo> Abrir para abrir um arquivo .tpl
existente. Em qualquer um dos casos, você acessa as definições do módulo contidas
no painel de modelos a partir de uma janela de modelos, como mostra a Figura 2.2.
See “A janela Modelo” na página 65 para informações adicionais.

10
 Figura 2.2 Janela de modelo de amostra

10
 Depois de definir os módulos que estarão contidos na biblioteca do painel de
modelos, é possível salvar as definições do módulo em um arquivo .tpl. Para
preparar o painel de modelo para uso em um modelo de simulação, um arquivo de
objeto do painel de modelo (.tpo) é gerado, usando o item de menu Verificar> Gerar
TPO. Esta etapa verifica se as definições do módulo estão completas e cria um
arquivo .tpo que está pronto para ser anexado para uso em um modelo.

Definições e instâncias do módulo

Um módulo no Arena é uma construção única que pode ser selecionada a partir de
um painel de modelos e colocada em um modelo existente ou, como veremos, na
definição de um novo módulo. Cada ícone em um painel de modelo representa um
único módulo, como um módulo Criar (para gerar entidades) ou um módulo Processo
(para processamento simples de entidades).
As informações sobre um módulo armazenado no arquivo da biblioteca do painel de
modelos (.tpl) são chamadas de definição de módulo. No arquivo de objeto do
painel de modelo (.tpo), as informações contidas nas definições do módulo são
condensadas para uso em um modelo de simulação. Quando um módulo é
selecionado em um arquivo .tpo e é colocado em uma janela de modelo, nos
referimos à representação do módulo na janela de modelo como uma instância do
módulo.
A definição do módulo descreve a estrutura do módulo e fornece dados e
visualização padrão do módulo. Cada vez que uma nova instância do módulo é
criada, a nova instância contém os padrões fornecidos pela definição do módulo. No
entanto, esses padrões podem ser modificados pelo modelador para que cada
instância carregue suas próprias características. Por exemplo, a caixa de diálogo
principal padrão do módulo Criar (fornecida pelo painel Processo Básico do modelo
Arena) exibe oito operandos que o modelador pode editar: o nome ou o rótulo do
módulo, o Tipo de Entidade (Tipo de Entidade (Entidade 1, por padrão), informações
relacionadas ao tempo entre as chegadas (o Tipo, Valor e o número de Unidades), o
número de Entidades por Chegada, o número Máximo de Chegadas e a hora da
Primeira Criação. (Veja a Figura 2.3.)
 Figura 2.3 Caixa de diálogo principal para o módulo Criar

A definição do módulo também especifica as características da caixa de diálogo do

módulo Criar, incluindo a posição dos operandos, os prompts associados a eles, seus
valores padrão e assim por diante. Quando um módulo Criar é colocado em uma
janela de modelo, uma instância é criada. Muitas instâncias de um determinado tipo
de módulo podem ser colocadas na janela do modelo. Por exemplo, o modelo de
simulação pode representar uma mercearia onde diferentes tipos de clientes chegam
em horários ou taxas variáveis. Primeiro, um módulo Criar é colocado na janela do
modelo. O modelador pode alterar os valores dos operandos da instância do módulo
Create. Por exemplo, o primeiro tipo de cliente pode usar o fluxo de chegada padrão,
que é aleatório (exponencial). Um segundo tipo de cliente pode chegar a uma taxa
constante. Nesse caso, um modelador pode alterar o valor em uma instância dos
módulos Create para Constant. Alterando o valor em uma instância, o modelador não
modifica a definição. No caso do módulo Create, a próxima instância (e todas as
instâncias, até a edição) terá um tipo de fluxo de chegada padrão Random (da
definição do módulo).
As instâncias do módulo podem ser colocadas nas janelas do modelo Arena (e salvas
posteriormente no modelo
arquivos .doe) ou nas janelas lógicas das definições de novos módulos (a serem salvos
nos arquivos .tpl). Por uma questão de simplicidade, geralmente discutimos o uso de
instâncias de módulo pelo "modelador" (sugerindo posicionamento nas janelas do
modelo) neste guia. No entanto, enquanto você lê, lembre-se de que as instâncias dos
módulos que você está definindo podem ser usadas em um modelo de simulação ou na
definição de um módulo em outro painel de modelos.

Definindo um módulo
Uma definição de módulo é criada trabalhando com cinco janelas: design da caixa
de diálogo, lógica, comutador, visualização do usuário e ícone do painel. Uma janela
12
 de modelo (veja a Figura 2.2) fornece uma base a partir da qual as janelas de
definição de módulo são abertas. Os itens em

12
o menu Janela abre cada uma das janelas da lista de Definições de módulo
selecionada. Os botões correspondentes na barra de ferramentas Desenvolvimento de
modelos também podem ser usados. Como é o caso em toda a Arena, você pode ter
quantas janelas abertas precisar para uma definição de módulo ou mais). A Figura 2.4
mostra uma janela de modelo com cinco janelas de definição de módulo abertas para
um único módulo de exemplo (Remessa).

Figura 2.4 Relação entre o modelo Arena e as janelas de definição de módulo

Os cinco botões usados para abrir as janelas de definição de módulo (na barra de
ferramentas mostrada na Figura 2.5) são organizados na ordem em que trabalhamos
com mais freqüência ao criar inicialmente um novo módulo; isto é, primeiro
definindo o design e a lógica da caixa de diálogo, depois definindo os interruptores
para controlar as opções de ativação e desativação do módulo e, finalmente,
adicionando a visualização do usuário e os gráficos dos ícones do painel. No entanto,
os cinco componentes de um módulo podem ser definidos em qualquer ordem. Ao
trabalhar com uma definição de módulo, você geralmente modifica o conteúdo de
várias dessas janelas.
Figura 2.5 Barra de ferramentas de desenvolvimento de modelos
Neste capítulo, apresentamos uma visão geral de cada uma das cinco janelas de
definição de módulo na ordem em que alguém que coloca uma instância de um
módulo irá interagir com o módulo. Começamos com o ícone do botão do módulo
que é exibido em um painel de modelos; depois, descrevemos a visualização do
usuário e o design e operandos da caixa de diálogo do módulo, que são os
componentes de uma instância do módulo que um modelador pode modificar
diretamente. Terminamos com a lógica e os comutadores subjacentes do módulo, que
não são diretamente acessíveis ao usuário de um módulo.

Ícone do painel
Três dos aspectos de uma definição de módulo são visíveis para o usuário do
módulo: o ícone do painel, a visualização do usuário e a caixa de diálogo e
operandos do módulo. Primeiro, quando o arquivo de objeto do painel de modelo
(.tpo) é anexado à Barra do projeto, os ícones do painel são exibidos. Esta é uma
tabela de pequenos ícones gráficos que representam os módulos contidos no painel
de modelos. A Figura 2.6 mostra o painel Processo básico do modelo Arena
conectado à barra de projeto.

Figura 2.6 Painel Modelo de processo básico

13
Embora o ícone do painel de um módulo esteja visível para o modelador, ele não
pode ser alterado; o ícone desenhado na definição do módulo será o mesmo sempre
que o arquivo .tpo for anexado à barra do projeto. A janela Ícone do painel usada
para desenhar o ícone na definição do módulo é semelhante à janela de edição de
imagem usada para desenhar imagens de recurso, entidade e assim por diante na
Arena. O ícone do painel para a definição do módulo Create do painel Basic
Process é mostrado na Figura 2.7.

Figura 2.7 Ícone do painel Criar módulo

Visualização do usuário
Depois que um módulo é selecionado e colocado em uma janela, uma instância é
formada e a visualização do usuário do módulo é exibida. Essa visualização do
usuário contém o identificador do módulo (o nome do módulo, exibido como um
objeto de texto em uma caixa que abre a caixa de diálogo principal do módulo
quando o modelador clica duas vezes nele) e pode conter pontos de entrada, pontos
de saída e valores de operando , gráficos de desenho estáticos e objetos de
animação. Os objetos na visualização do usuário são visíveis para o modelador; a
maioria é alterável pelo modelador individualmente em cada instância do módulo.
Por exemplo, você pode colocar um módulo Processo (no painel Processo Básico)
em uma janela de modelo. Inicialmente, a visualização do usuário (na janela do
modelo) aparecerá como mostrado na Figura 2.8, contendo o identificador do
módulo (“Processo #”), um ponto de entrada, um ponto de saída,

Figura 2.8 Visualização de usuário padrão da instância do módulo de processo

Você pode colocar outra instância do módulo Process no mesmo modelo e adicionar
uma imagem de animação de recurso para essa instância do módulo Process para
representar o recurso usado no módulo. A Figura 2.9 mostra as visualizações
modificadas do usuário de duas instâncias do módulo Process usando imagens da
biblioteca de imagens people.plb do Arena, no lugar das imagens de recursos padrão.
Figura 2.9 Instâncias do módulo Process Modified

A visualização do usuário para uma definição de módulo é criada na janela

Visualização do Usuário. Na Figura 2.10, você pode ver que a janela de exibição do
usuário para o módulo Process contém mais objetos do que os exibidos por padrão
quando uma instância do módulo Process é colocada pela primeira vez em uma janela.
Esses objetos adicionais de exibição do usuário não são exibidos porque os valores
dos operandos na caixa de diálogo padrão do módulo de processo fazem com que eles
sejam "trocados". (Discutiremos as opções mais adiante neste capítulo.)

Figura 2.10 Janela de visualização do usuário da definição do módulo Process da

Arena

Design e operandos da caixa de diálogo

Uma parte importante de uma definição de módulo é a interface do usuário, a parte
visual que um modelador vê ao abrir a caixa de diálogo de um módulo ou exibir os
campos de um módulo na planilha de módulo.
Freqüentemente, a parte mais desafiadora da criação de um módulo é selecionar
quais operandos devem ser apresentados aos modeladores, os valores padrão e as
características de exibição destes.
operandos e sua organização em uma ou mais caixas de diálogo para o módulo. Um
designer de módulo pode decidir fornecer apenas alguns operandos; os modeladores
que usam este módulo têm poucas opções, mas são capazes de trabalhar com um
módulo muito simples. Módulos complexos podem apresentar dezenas de
operandos, permitindo que um único módulo capture um processo muito complicado
que pode variar significativamente de sistema para sistema ou em casos diferentes
em um sistema. Além disso, através do uso de comutadores, a caixa de diálogo pode
ser reconfigurada para exibir apenas os operandos apropriados, com base nos
valores de outros operandos fornecidos pelo modelador.
No módulo Registro do painel Processo Básico, por exemplo, a caixa de diálogo
padrão que é aberta quando uma instância é formada pela primeira vez aparece
como mostrado na Figura 2.11.

Figura 2.11 Caixa de diálogo padrão do módulo de registro

Se o modelador alterar o campo Tipo de Contagem para Intervalo de tempo em

uma instância do módulo Registro, um operando diferente será exibido com o
prompt "Nome do Atributo" no lugar do operando "Valor" e o operando "Nome do
Registro" será solicitado. de "Nome do contador". Nesse caso, o modelador
coletará informações sobre a diferença horária entre o valor do nome do atributo
especificado e o tempo atual da simulação, em vez de aumentar ou diminuir uma
contagem especificada.
Em um arquivo da biblioteca do painel de modelos (.tpl), a janela Design da caixa
de diálogo é a interface para definir o (s) layout (s) de formulário da caixa de
diálogo e os operandos de uma definição de módulo. Nesta janela, um designer de
módulo define os tamanhos das caixas de diálogo, os dados exibidos e inseridos
pelo usuário, os valores padrão e permitidos e o layout dos controles da interface.
A janela de design da caixa de diálogo inclui uma seção Operand Explorer para
navegar na hierarquia de caixas de diálogo da definição do módulo (muitos módulos
contêm várias caixas de diálogo), operandos e grupos de repetição (para definir
operandos ou conjuntos de operandos repetíveis, como os recursos a serem utilizados
em um processo). Ele também inclui uma caixa de ferramentas
seção para adicionar controles da interface do usuário aos formulários da caixa de
diálogo do módulo e uma grade Propriedades do Design para editar as propriedades
de um ou mais objetos selecionados.
A Figura 2.12 mostra a janela de design da caixa de diálogo para a definição do
módulo Lote do painel Processo Básico, que contém uma caixa de diálogo
principal e vários operandos que são membros da caixa de diálogo.

Figura 2.12 Janela de design da caixa de diálogo para a definição do módulo Batch

Um modelador que trabalha com uma instância do módulo pode modificar os valores
dos operandos, mas não pode alterar a configuração das caixas de diálogo, os valores
padrão fornecidos quando uma nova instância de um módulo é colocada em uma
janela ou as associações entre operandos. Essas características dos dados de um
módulo fazem parte da definição do módulo; cada instância fornece valores aos
operandos fornecidos pela definição.

Lógica
Os dois aspectos finais de um módulo estão ocultos do modelador: a lógica do
módulo e a definição de comutadores de módulo. A lógica subjacente a uma
definição de módulo Arena
é criado através da construção de um "submodelo" da Arena. A janela Logic,
usada para criar a lógica de uma definição de módulo, é muito semelhante a uma
janela do modelo Arena; você anexa painéis à barra de projetos, seleciona e
posiciona os módulos e edita as instâncias do módulo que você criou.
A janela lógica é a segunda janela no Arena que pode conter instâncias de módulos.
Como mencionado anteriormente, neste guia, discutimos com mais freqüência o
posicionamento de módulos nas janelas do modelo pelo modelador. Essas
discussões também se referem à criação da lógica do módulo, a menos que indicado
de outra forma.
Quando a janela lógica está ativa, a barra de ferramentas Executar não está disponível
porque as definições do módulo Arena não podem ser simuladas - apenas instâncias
nos modelos podem fazer parte de uma execução de simulação. Além disso, por
padrão, os objetos de animação em uma janela lógica não são exibidos, pois são úteis
principalmente apenas para representar o comportamento de uma simulação em
execução. Você pode ativar a exibição dos objetos de animação na janela usando o
item de menu Exibir> Camadas.
Um aspecto importante da definição dos módulos Arena é o vínculo entre os
operandos e a lógica. Os operandos fornecem a interface externa para um modelador;
a lógica é o comportamento interno do módulo nas circunstâncias definidas pelos
valores dos operandos. Um modelador pode personalizar a lógica de um módulo cada
vez que uma nova instância do módulo é colocada, fornecendo valores diferentes para
os operandos do módulo.
O mecanismo para passar valores de operando da caixa de diálogo da instância do
módulo para a lógica subjacente do módulo é através de referências de operando
estabelecidas na janela lógica da definição do módulo.
Para ilustrar isso, vamos considerar um módulo que representa um funcionário de
internações em um hospital. As entidades que fluem através deste módulo
representam pacientes ou familiares que precisam fornecer informações sobre
admissões. Os modeladores que usam este módulo de Auxiliar de Admissão
fornecerão o nome do funcionário e o tempo para processar uma admissão. Na lógica
subjacente, usaremos o módulo Process no painel Basic Process. Uma caixa de
diálogo de amostra para o módulo Admissions Clerk é mostrada na Figura 2.13.
Figura 2.13 Caixa de diálogo para o módulo Auxiliar de hospitalização
Em cada instância do módulo Administrador de Admissões, valores diferentes podem
ser fornecidos para os dois operandos do módulo (Nome do Funcionário e Tempo para
Admissão). Para usar esses valores, passaremos o valor do operando Nome do
Funcionário para o campo Nome do Recurso no módulo Processo, e o operando
Tempo para Admitir para o campo Expressão.
Para referenciar um operando do módulo de uma instância (como o módulo Process),
edite a instância na janela lógica; onde quer que você planeje usar o valor de um
operando do módulo, coloque o nome do operando entre aspas (`). Supondo que os
operandos tenham o mesmo nome que os prompts (ou seja, Nome do Funcionário e
Hora de Admissão), as referências serão estabelecidas no módulo Processo como
`Nome do funcionário 'e` Hora de admitir`, como mostra a Figura 2.14.

Figura 2.14 Referências do operando no módulo Process para o módulo Admissions

Clerk

Se uma instância do módulo auxiliar de admissão tiver valores Mary e

UNIFORM (10,30) para os operandos do módulo, um módulo Process será
colocado na lógica do modelo subjacente com valores de Mary para o recurso
a ser usado e UNIFORM (10,30) pelo tempo do processo.
 Diferente da visão do usuário e dos operandos de uma instância do módulo, a lógica
do módulo não pode ser diretamente modificada por um modelador. Em vez disso, os
operandos do módulo podem ser usados para especializar uma instância de um
módulo para atender a uma necessidade específica, passando dados para a lógica (ou
seja, as instâncias do módulo na janela lógica) e alternando ou desativando seções da
lógica.
Pode haver um ou mais operandos em uma instância do módulo lógico (na janela
lógica) que não estão disponíveis para o usuário final. Por exemplo, na descrição do
módulo Processo acima, o Tipo permanece o padrão padrão, Ação é Liberar atraso de
apreensão, Prioridade é o padrão de Médio (2) e Tipo de atraso é Expressão. Esses
valores de operando não podem ser alterados por um modelador, porque não são
acessíveis a partir de operandos em seu módulo.

Comuta
Em uma definição de módulo Arena, objetos individuais na visualização do usuário,
design da caixa de diálogo e janelas lógicas podem ser selecionados para serem
incluídos em uma instância apenas se uma condição específica for verdadeira. Por
exemplo, uma instância do módulo Registro no painel Processo básico exibe apenas
o operando Valor se o Tipo for Contagem ou Expressão. Se o Tipo for Estatísticas da
entidade, Intervalo de tempo ou Tempo entre, o operando Valor não será exibido. Em
vez disso, outros operandos relacionados a esses tipos de estatísticas são exibidos.
Nós nos referimos a isso como "trocados". Na lógica do módulo subjacente, um
bloco Count é incluído na lógica, com os valores apropriados referenciados nos
operandos do módulo, se Type for Count. Um bloco Tally é usado, com informações
variadas, se Tipo for Estatísticas da entidade, Intervalo de tempo, Tempo entre ou
Expressão. E finalmente,
Para definir esse comportamento, objetos chamados comutadores são criados na
definição do módulo. Esses comutadores são colocados em uma janela de
comutador, como mostra a Figura 2.15.

20
 Figura 2.15 Janela do comutador de amostra

20
A definição de um comutador é baseada em condições que envolvem os valores dos
operandos, como `Type` ==“ Count ”, que define um comutador cujo valor é
verdadeiro sempre que o operando Type tiver um valor igual a Count. Os operandos
são referenciados colocando o nome do operando entre aspas, como na janela lógica.
Os valores estão entre aspas duplas. Para usar um comutador na visualização do
usuário ou nas janelas lógicas, o comutador é "anexado" ao objeto. Na janela de
design da caixa de diálogo, uma opção é adicionada a um objeto, especificando a
propriedade SwitchName do objeto. A exibição de um objeto que possui um
comutador conectado é alterada para mostrar o nome do comutador entre colchetes,
conforme mostrado para um bloco Tally na janela lógica na Figura 2.16.

Figura 2.16 Bloco Tally com interruptor conectado na janela lógica

O uso de comutadores nas definições do módulo pode ajudar os usuários do foco a

atenção do módulo apenas nos campos relevantes, dadas outras informações
fornecidas (por exemplo, se um modelador indicou que um tipo de contagem de
estatística deve ser coletado, não há motivo para exibir o campo Nome do Tally).
Além disso, os comutadores usados na janela lógica podem garantir que modelos
eficientes sejam gerados para a execução de simulações. No caso do módulo Record,
em vez de exigir que cada entidade indague se uma contagem deve ou não ser
coletada, a lógica é gravada para que todas as entidades sejam executadas ou é
omitida do modelo inteiramente se nenhuma contagem precisar ser coletada. .
Obviamente, em alguns casos, entidades diferentes podem passar por uma lógica
diferente, nesse caso, um módulo como o módulo Decidir (no painel Processo básico)
pode ser colocado na janela lógica para tomar a decisão. Porém, se uma seleção
específica for aplicada a todas as entidades processadas por meio do módulo, os
comutadores são uma maneira eficaz de garantir uma lógica de simulação eficiente.
Elementos e propriedades
Os conceitos que apresentamos até agora estão relacionados à construção de
módulos, em que cada definição de módulo é uma unidade independente. Quando
um módulo é colocado em um modelo, suas características são específicas para a
instância; uma alteração no valor de um operando ou na aparência de um objeto na
visualização do usuário não afeta outros módulos do mesmo tipo.
No entanto, existem algumas construções em um modelo de simulação que são
inerentemente globais por natureza. Nós nos referimos a eles como elementos do
modelo. Esses elementos podem ser referenciados por mais de uma instância do
módulo, e a criação de um elemento coloca o nome do elemento em uma lista
acessível por outras instâncias do módulo.
Por exemplo, se você colocar um módulo Process no modelo Arena, poderá
especificar "Packer" como o nome do recurso a ser capturado e liberado. Ao fazer
isso, você cria um novo elemento de recurso chamado Packer. Se você colocar outro
módulo Process e puxar a lista associada ao campo Nome do recurso, verá que o
Packer aparece na lista.
Os elementos são separados em tipos como filas, recursos ou transportadores. Cada
um desses tipos tem seu próprio conjunto de características, conhecido como
propriedades. Uma fila possui propriedades como uma regra de classificação; os
recursos têm capacidades, falhas e assim por diante; e os transportadores têm
propriedades como velocidade e tipo (acumulação ou não acumulação). (Ver
apêndice B“Tabelas” na página 217 para obter uma lista de todos os tipos de
elementos e suas propriedades.)
Cada elemento específico definido em um modelo possui seus próprios valores para
suas propriedades. Por exemplo, um elemento de recurso chamado Clerk pode
seguir uma programação de capacidade chamada Early Day; outro elemento de
recurso chamado Supervisor pode seguir uma programação chamada Dia normal.
É importante observar que as propriedades de um elemento específico, como o
recurso Clerk, são globais para todo o modelo de simulação. Se o Clerk inicialmente
for definido por um módulo Process no painel Process Basic e você editar um
módulo Resource (também no painel Process Basic) no modelo, o Packer de
recursos será especificado automaticamente, com informações padrão, como tipo e
capacidade .
Em uma definição de módulo, na janela de design da caixa de diálogo, você
identifica operandos específicos que definirão elementos especificando na
propriedade LogicProperties do operando que o tipo de operando é Element. Da
mesma forma, um operando que define uma propriedade de um elemento recebe o
tipo Property. O capítulo "Elementos" apresenta uma discussão mais detalhada do

22
conceito de elementos e suas propriedades. Veja o"O Janela Design de Diálogo ”na
página 77 para obter informações sobre como definir operandos de elemento e
propriedade.

23
Hierarquia da arena e SIMAN
O Arena emprega uma arquitetura hierárquica para modelagem de simulação - ou
seja, os módulos são definidos utilizando outros módulos. Essa abordagem oferece
muitos benefícios. Módulos que representam subconjuntos de um processo ou
conjunto de processos semelhantes podem ser desenvolvidos e verificados uma vez
e, em seguida, podem ser reutilizados para definir novos módulos de nível superior
que correspondem a um processo; como uma CPU do computador, um agente de
tíquetes ou uma etiquetadora de linha de conservas. Os módulos de componentes
(por exemplo, selecione a próxima tarefa a ser processada, digite o nome do
passageiro ou a etiqueta do invólucro) também podem ser usados diretamente nos
modelos para capturar com precisão a natureza de sistemas complexos ou de
elementos do sistema que possuem facetas peculiares não representadas por um
nível superior. módulos.
Os módulos básicos da hierarquia da Arena representam a linguagem de simulação
do SIMAN. Esses módulos formam o modelo SIMAN, que contém dois painéis:
Blocos e Elementos. O painel Blocos consiste em módulos que geram blocos em um
arquivo do modelo SIMAN (.mod), como Atraso ou Filial. Muitos dos módulos no
modelo Arena recebem o mesmo nome que os módulos Blocks e executam a mesma
função que os correspondentes do painel Blocks. No entanto, os módulos no Arena
oferecem opções para os tipos de informações que devem ser colocadas em um
operando (por exemplo, se o tipo de elemento a ser atribuído a um valor é um
atributo, uma variável, uma imagem etc.), e defina a lógica do modelo (ou seja,
blocos) e os elementos (ou seja, informações a serem gravadas no arquivo
experimental do SIMAN).
O painel Elementos consiste em módulos que representam cada um dos tipos de
elementos no arquivo de experiência do SIMAN (.exp), como recursos, filas ou
contadores. Muitos módulos de dados nos painéis de modelo Arena (por exemplo,
recursos, filas, transportadores) correspondem aos módulos no painel Elementos.
Quando você cria uma nova definição de módulo, uma das etapas é definir a lógica
associada ao módulo. Ao fazer isso, você anexa um ou mais painéis de modelo à
barra de projetos e coloca instâncias de módulos. Se esses módulos vierem do
modelo SIMAN (painéis Blocos / Elementos), quando um modelador usa seu
módulo, o modelo SIMAN final e o experimento usados para uma execução de
simulação são gerados diretamente através dos módulos que você colocou. Isso
pode ser pensado como um módulo usando um único nível de hierarquia, conforme
ilustrado na Figura 2.17.
Figura 2.17 Nível único da hierarquia de módulos (módulos SIMAN na janela lógica)

Um modelador (ou designer de modelo) que usa o Módulo A não precisa entender
sobre a estrutura subjacente do módulo (ou seja, o conteúdo da janela lógica). Em
vez disso, você criou uma nova interface para um módulo DELAY seguido por um
módulo SIGNAL, definindo os operandos do Módulo A e estabelecendo as
referências a esses operandos nos módulos DELAY e SIGNAL contidos na janela
lógica. Como designer de modelo, você tem controle total sobre quais características
da lógica subjacente são alteráveis pelos usuários do módulo e quais características
são fixadas nos valores que você escolheu.
Para estender o conceito de hierarquia para outro nível, você pode usar uma
instância do Módulo A na janela lógica de um módulo (Módulo B) em outro arquivo
do painel de modelo. Aqui você tem a opção de usar os componentes subjacentes do
Módulo A (DELAY e SIGNAL) diretamente; ou, em vez disso, você pode alavancar
o esforço que você já dedicou ao projetar e verificar o ModuleA. A Figura 2.18
ilustra a hierarquia de uma definição de exemplo do ModuleB, incluindo uma
instância do ModuleA (construída hierarquicamente com os módulos do painel
Blocks na base) e uma instância (COUNT) diretamente obtida no painel Blocks.

Figura 2.18 Hierarquia em várias camadas

 Embora o conceito de hierarquia seja extremamente poderoso, não é necessário que
os modeladores entendam que a ferramenta que eles estão usando é construída
hierarquicamente ou qual é a estrutura hierárquica subjacente. Para os
desenvolvedores de modelos, a hierarquia é uma oportunidade a ser explorada para
alavancar esforços, reutilizar abordagens de modelagem verificadas e incentivar a
consistência do design.

Fluxogramas e módulos de dados

Embora todos os módulos tenham muitos recursos em comum, às vezes é útil no
design de um modelo distinguir entre os módulos "fluxograma" e "dados". Usamos o
termo módulo de fluxograma para se referir a um módulo que permite o fluxo de
entrada e saída de entidades, como os seguintes módulos exibidos no painel Processo
básico da Arena: Criar, Dispor, Processar, Decidir, Lote, Separar, Atribuir e
Registrar. Estes são os módulos fundamentais de processamento que atuam nas
entidades.
Por outro lado, as entidades não fluem para dentro ou para fora dos módulos de
dados. Esses módulos de dados são colocados para fornecer informações sobre
elementos de um modelo de simulação. Os módulos de dados no painel Processo
básico incluem: Entidade, Fila, Recurso, Variável, Agenda e Conjunto.
Enquanto os módulos do fluxograma são colocados na janela do modelo e são
conectados para formar um fluxograma e descrever a lógica do seu sistema, os
módulos de dados não são colocados na janela do modelo. Em vez disso, eles são
editados a partir de uma interface de planilha. Para obter mais informações sobre
como definir um módulo como um módulo de dados, consultee “Definindo módulos
de dados” em página 74.

Uso de modelos
Introdução
Os modelos podem ser desenvolvidos usando o Arena para atender a uma ampla
gama de necessidades. Alguns modelos serão concebidos para serem utilizados por
um grande mercado-alvo; outros serão destinados ao uso do designer de modelos
para aumentar a produtividade na construção de modelos de simulação. Nesta seção,
descrevemos alguns dos possíveis usos dos recursos de desenvolvimento de modelos
do Arena. Estamos confiantes de que esta lista representa apenas a ponta do iceberg.

Ferramentas gerais de modelagem

Os primeiros modelos desenvolvidos na Arena foram os modelos SIMAN e Arena.
Os dois painéis que compõem o modelo SIMAN - Blocos e Elementos - fornecem
uma
interface gráfica para a linguagem SIMAN para modeladores e formar a base de
todos os módulos da Arena. Os três painéis que compõem o modelo Arena -
Processo Básico, Processo Avançado e Transferência Avançada - fornecem
módulos que capturam processos e elementos do sistema comumente encontrados
usando terminologia genérica (por exemplo, processar, decidir, gravar).
Na área de fabricação, os modeladores exploraram os poderosos recursos
incorporados no SIMAN e na Arena para capturar características essenciais do
sistema, incluindo cronogramas operacionais, planos de processo, sistemas
automatizados de manuseio de materiais e assim por diante. Os modeladores
também aplicaram o modelo Arena para representar sistemas como operações de
linhas aéreas, assistência médica, logística, distribuição e reengenharia de
processos de negócios (BPR). E, mesmo em algumas organizações, o Arena tem
sido usado para um amplo espectro de estudos de simulação, desde o planejamento
de longo alcance até a análise de alterações de sistema no curto prazo.
A força de uma ferramenta geral de modelagem, usada em um ambiente único e
coeso, é que os modeladores recebem um conjunto principal de termos e conceitos
que podem ser aplicados a muitos problemas diferentes. O conhecimento adquirido
no estudo de um sistema pode ser prontamente aplicado na execução do próximo
projeto de simulação.

Ambientes orientados para a indústria

Também foram desenvolvidos modelos para uso em um setor específico, como
fabricação de bolachas no setor de semicondutores. Esses modelos podem ser
desenvolvidos para uso comercial ou, no caso de uma organização que fornece
suporte a um setor, os modelos podem ser desenvolvidos e disponibilizados para
empresas do setor.
Existem duas vantagens principais dos modelos focados no setor. Primeiro, o modelo
pode usar a terminologia apropriada para o setor para minimizar a abstração
necessária para um modelador converter um sistema na ferramenta de software de
simulação. Mais importante, através do poder proporcionado pelos modelos
hierárquicos do Arena, é possível criar um modelo totalmente customizado para
representar com precisão os elementos dos sistemas do setor, em vez de mapear a
funcionalidade de modelagem existente fornecida por uma ferramenta de modelagem
geral. O designer do modelo tem os recursos disponíveis para imitar exatamente o
comportamento de equipamentos, pessoas, peças, componentes e assim por diante,
fornecendo qualquer espectro de opções apropriado para as variações desses
elementos do sistema.

Ferramentas focadas em aplicativos

Muitos dos modelos desenvolvidos usando o Arena ajudarão os modeladores a
representar um sistema, instalação ou processo específico. Ao criar esses modelos, o
designer de modelos terá um foco mais restrito do que o desenvolvedor de um
modelo geral.
modelo de modelagem ou modelo a ser amplamente utilizado em um setor. Por
exemplo, um modelo pode ser construído para uso na análise de linhas de montagem
de motores em uma empresa automotiva ou para representar a entrega de produtos
farmacêuticos em um hospital. O escopo do modelo não é grande o suficiente para
abranger um grande subconjunto de problemas em um setor específico; em vez disso,
os módulos contidos no modelo estão focados em um aplicativo específico que pode
aparecer em muitos sistemas ou instalações.
Esses modelos focados em aplicativos se beneficiam da estrutura hierárquica do
Arena da mesma maneira que os modelos focados no setor: a interface apresentada
ao modelador pode ser personalizada para ser muito familiar (tanto em termos de
animação gráfica quanto na terminologia usada nas caixas de diálogo dos
módulos); e partes, processos e assim por diante, nos ambientes de aplicativos de
destino, podem ser representados com precisão.
Em alguns casos, um modelador pode criar um modelo para seu uso individual. Em
outros casos, modelos podem ser criados para uso entre alguns modeladores em um
grupo comum; muitos modelos focados em aplicativos serão compartilhados entre
diferentes grupos de modelagem em uma organização.

Melhorando a produtividade da modelagem e

compartilhando a tecnologia de modelagem
Para um modelador, o Arena oferece a oportunidade de reutilizar técnicas de
modelagem aprendidas no processo de construção de modelos. Na evolução das
ferramentas de programação, o código reutilizável foi capturado em procedimentos,
sub-rotinas e funções. Posteriormente, ferramentas orientadas a objetos permitiram
definir todas as características dos "objetos" representados no software para
reutilização. Um módulo pode ser considerado análogo a um objeto (em software
orientado a objetos) - o módulo permite capturar as características completas de um
processo que você deseja modelar em um pacote independente que você pode
reutilizar e que pode ser usado. personalizado em cada uso.
Ao permitir que você colete todas as características importantes de um elemento do
sistema simulado (isto é, a lógica, a animação e os dados) em um único módulo, o
Arena o incentiva a reutilizar e compartilhar o que aprendeu.
Por exemplo, ao modelar uma rede de computadores, você pode desenvolver um
conjunto de módulos que capturam a lógica para alocar trabalhos a uma impressora.
Cada vez que você precisar modelar outra impressora, poderá copiar a lógica
diretamente no modelo (selecionando e duplicando todos os módulos que
representam a lógica). Ou, usando o Arena, você pode criar um único módulo para
representar a impressora, incorporando a lógica na definição do módulo. A segunda
abordagem - criar um módulo reutilizável de “impressora” diminui a probabilidade
de você cometer um erro ao reutilizar a representação original da impressora,
incentiva você a reutilizar o que aprendeu e facilita muito o compartilhamento com
outras pessoas da modelagem abordagem que você desenvolveu.
3 Tutorial de criação de módulos
Neste capítulo, construiremos um pequeno módulo para ilustrar os conceitos
fundamentais da criação de modelos no Arena. Apresentamos este material com o
objetivo de fornecer um tutorial passo a passo que você pode seguir usando o
software Arena. Se você seguir as instruções deste capítulo, no final do tutorial, você
terá construído um módulo completo representando uma estação de impressão de
computador de alta velocidade e criado um modelo de simulação usando-o. Embora
o módulo que você criar seja bastante simples, ele inclui os principais elementos das
definições do módulo: uma caixa de diálogo com alguns operandos, lógica de
simulação, uma visualização do usuário com animação e um ícone no painel.
À medida que você constrói o módulo descrito neste capítulo, pode ser útil revisar o
Capítulo 2, “Visão Geral do Desenvolvimento de Modelos de Arena”, que fornece
definições de termos importantes e explica conceitos críticos relacionados à criação
de modelos.
Começamos descrevendo o módulo que deve ser construído. A seguir, apresentamos
seções que documentam o procedimento usado em quatro janelas de definição de
módulo (design da caixa de diálogo, lógica, visualização do usuário e ícone do
painel) para criar o módulo. Finalmente, usamos o módulo para construir um
pequeno modelo de simulação.

Visão geral do módulo

Para ilustrar o processo de construção de um módulo no Arena, criaremos um
módulo que representa uma estação de impressão de alta velocidade em uma rede
de computadores. Os modelos que usam este módulo Impressora conterão
entidades que representam trabalhos de impressão.
Nosso módulo Impressora será análogo a um servidor; isto é, aceitará entidades a
serem processadas e enviará as entidades, após o processamento, para outro
módulo. Não cria ou descarta entidades.
A lógica capturada pelo módulo Impressora inclui o conceito de mudança. Se o tipo
de trabalho que está sendo impresso (representado por um atributo de entidade)
mudar de um trabalho para outro, um técnico receberá um sinal para executar uma
atividade de troca, como a alteração do tipo de papel usado pela impressora.
Ao projetar um módulo como o exemplo Impressora, uma das decisões importantes a
serem tomadas é quais operandos serão apresentados ao modelador. Se você
apresentar apenas alguns operandos importantes, os modeladores receberão uma
interface simples que focaliza a atenção nas características mais importantes do
processo representado pelo módulo. No entanto, ao limitar o número de operandos
29
apresentados, você também coloca um

30
UMARENA TEMPLATE DEVELOPER"S
GUIDE

restrição à flexibilidade de um modelador para adaptar o módulo para

representar um sistema específico com precisão.
Neste tutorial, começaremos pequenos e forneceremos apenas alguns operandos com
o módulo Impressora. Porém, lembre-se de que muitas opções adicionais podem ser
fornecidas a um modelador, expandindo os operandos definidos no módulo. Depois
de criar o módulo Impressora descrito no tutorial, você pode tentar expandir este
exemplo colocando operandos adicionais para fornecer outras opções para o
modelador.
A caixa de diálogo do módulo Impressora é mostrada na Figura 3.1.

Figura 3.1 Caixa de diálogo do módulo da impressora

No módulo Impressora, o modelador insere as seguintes informações:

 o Nome da impressora, que fornecerá o nome do recurso da impressora, bem
como o nome da fila para as entidades que aguardam pelo recurso da
impressora,
 o técnico que realiza a troca, que definirá um recurso,
 o Tempo de mudança, usado apenas durante trocas entre tipos de trabalho e
 o tempo de impressão, ou seja, o tempo necessário para imprimir todo o trabalho.
A janela lógica associada ao módulo Impressora concluída é mostrada na Figura
3.2 Para que você entenda a lógica que planejamos representar pelo módulo
Impressora, fornecemos uma breve descrição nesta seção. É usada uma combinação
de módulos dos painéis SIMAN Blocks and Elements e do painel Basic Process da
Arena. Instruções passo a passo para criar essa lógica são apresentadas mais adiante
neste capítulo.
 Figura 3.2 Lógica do módulo da impressora

Uma entidade do trabalho de impressão que chega ao módulo Impressora começa

a processar na instância do módulo Fila. O trabalho de impressão aguarda para
aproveitar o recurso da impressora e, em seguida, testa no módulo Decidir para
determinar se uma mudança deve ocorrer.
Se houver uma mudança, a entidade seguirá o caminho lógico da mudança
(mostrado da saída True para o módulo Assign). Nesse caso, ele altera uma variável,
`Printer Name`_Change, para o valor de 1 para indicar que uma mudança está
ocorrendo e a realiza no módulo Process. Após a troca, a entidade do trabalho de
impressão restaura a variável de troca para 0 e altera uma variável que registra o
último tipo de trabalho processado na impressora (para o tipo de trabalho da
entidade).
Se nenhuma mudança for necessária, a entidade será enviada da condição Else (ou
false) do módulo Decide diretamente para o módulo Delay para processar o trabalho
de impressão. Se for necessária uma troca, a entidade entra no módulo Atraso após
concluir o processo de troca. Após o atraso do tempo de impressão, a entidade do
trabalho de impressão libera o recurso da impressora.
Para criar a lógica do módulo Impressora, é possível criar o submodelo diretamente
na janela lógica da definição do módulo ou preparar um modelo de Arena com a
mesma lógica. Se você construir a lógica primeiro como um modelo Arena, poderá
usar o Run Controller da Arena e visualizar a animação detalhada da lógica do
módulo executando uma simulação da lógica diretamente, e não através de uma
instância do módulo Impressora. Usando essa abordagem, depois de ter certeza de
que a lógica foi especificada como você deseja, é possível copiar a lógica verificada
da janela do modelo para a janela de lógica do módulo Impressora usando a área de
32
.
 transferência da Arena.

32
.
 Para os fins deste tutorial, no entanto, apresentamos o módulo Impressora, definindo
a lógica diretamente na janela lógica da definição do módulo. Dessa forma,
podemos discutir o problema de amostra a ser resolvido (ou seja, o módulo da
estação de impressora de alta velocidade) e os aspectos específicos relacionados à
criação de módulos. Você pode criar a lógica mostrada na Figura 3.2 em uma janela
de modelo primeiro para desenvolver um entendimento do módulo que criaremos
neste tutorial.
Apresentaremos as janelas de definição do módulo Impressora na seguinte ordem:
Design da caixa de diálogo, Lógica, Visão do usuário e Ícone do painel. Fazemos isso
porque achamos importante considerar juntos a lógica do módulo e os operandos ao
projetar um módulo. Neste tutorial, apresentamos a janela de design da caixa de
diálogo primeiro porque ela pode ser completamente definida e testada sem a lógica
subjacente do módulo. A lógica, por outro lado, é difícil de testar sem operandos para
fornecer uma interface para definir os dados que podem mudar de instância para
instância do módulo. Quando você estiver desenvolvendo seus próprios módulos,
provavelmente descobrirá que você alterna entre definir a lógica do módulo e
adicionar operandos na janela de design da caixa de diálogo, que achamos ser uma
maneira natural de criar uma definição completa do módulo.

Introdução - Um novo modelo

O módulo Impressora que desenvolveremos fará parte de um novo arquivo de painel
de modelo. Para trabalhar com um novo painel de modelo, abra uma nova janela de
modelo selecionando Arquivo> Novo na barra de menus principal e escolhendo
Janela de modelo como o novo tipo de arquivo. Isso abre uma janela de modelo,
como mostra a Figura 3.3.
Figura 3.3 Janela Novo modelo
 O primeiro passo na definição de um módulo é nomeá-lo. Clique no botão
Adicionar, digite o nome do módulo, Impressora e escolha OK. Como você verá no
módulo completo, seu nome é usado para o seguinte:
 o rótulo de texto padrão exibido no ícone do painel (apenas as quatro
primeiras letras são exibidas, mas podem ser editadas),
 o nome exibido em um painel de modelo se o tipo de exibição for texto (em
vez de ícone),
 o nome padrão do objeto da caixa de diálogo principal do módulo (definido na
janela de design da caixa de diálogo),
 o título padrão da caixa de diálogo principal do módulo e
 o nome padrão do identificador do módulo (definido na janela de visualização do
usuário).
Para abrir cada uma das janelas de definição do módulo, verifique se o módulo
Impressora está selecionado na lista Definições do módulo. Para selecioná-lo,
clique no nome do módulo.
Voltaremos à janela do modelo em "Um modelo de amostra" em página 57 para
preparar o arquivo do painel de modelo para uso em um modelo Arena.
Nota: Para salvar o painel de modelos em uma biblioteca de painéis de modelos
(.tpl), selecione o item de menu Arquivo> Salvar na barra de menus principal.

Design de Diálogo
A janela de design da caixa de diálogo
Começamos a projetar o módulo Impressora, definindo o design da caixa de diálogo
e seus operandos. Abra a janela de design da caixa de diálogo selecionando o módulo
Impressora (no
definições de módulo da janela do modelo) e selecione a janela> caixa de diálogo
Projeto item de menu ou clique no botão da barra de ferramentas Dialog Design
Window na barra de ferramentas Template Development. Isso abre a interface de
design da caixa de diálogo para o módulo Impressora, como mostra a Figura 3.4.

33
Figura 3.4 Janela de design da caixa de diálogo

A janela de design da caixa de diálogo consiste nos seguintes componentes:

 Formulário de Diálogo—o layout do formulário da caixa de diálogo é
exibido no centro da janela.
 Caixa de ferramentas—Fornece uma interface para adicionar controles (por
exemplo, caixas de texto, caixas de combinação ou botões da caixa de diálogo) e
gráficos estáticos (por exemplo, texto, linhas ou caixas de grupo) aos layouts de
formulário da caixa de diálogo.
 Operand Explorer- exibe a organização hierárquica dos objetos de formulário,
operando e grupo de repetição da caixa de diálogo que definem a estrutura da
caixa de diálogo do módulo.
 Propriedades de design—Fornece uma interface para exibir e / ou editar
propriedades do (s) objeto (s) selecionado (s) no momento.
Quando a janela de design da caixa de diálogo de uma definição de módulo é aberta,
por padrão, o formulário da caixa de diálogo principal do módulo é exibido no
centro da janela. Assim, para nossa definição de módulo de impressora, vemos um
formulário de caixa de diálogo chamado "Impressora". Essa é a caixa de diálogo que
será exibida quando o modelador clicar duas vezes em uma instância de um módulo
Impressora em uma janela de modelo.
Para especificar as dimensões do formulário da caixa de diálogo, vá para a janela
Propriedades do design. Essa janela deve exibir as propriedades do objeto Printer
DialogForm.
Edite as linhas de propriedades Altura e Largura e insira uma altura de 110 e uma
largura de
170.

Figura 3.5 Propriedades de design do objeto Printer DialogForm

Você também pode redimensionar um formulário de caixa de diálogo. Primeiro

clique em qualquer lugar do formulário para garantir que ele esteja selecionado. Em
seguida, clique e arraste uma das alças de dimensionamento que aparecem na borda
do formulário. As alças de dimensionamento se assemelham a pequenas caixas pretas
e o ponteiro se transforma em uma seta de duas pontas quando você aponta para a
alça.

Adicionando operandos da caixa de diálogo do módulo

A caixa de diálogo do módulo Impressora incluirá quatro operandos visíveis que
podem ser editados pelo usuário (como mostrado anteriormente na Figura 3.1):
Nome da impressora (controle da caixa de combinação), Técnico (controle da caixa
de combinação), Tempo de mudança (controle da caixa de texto) e Impressão Hora
(controle da caixa de texto).
NOME DA IMPRESSORA OPERANDO
Para adicionar o operando Nome da impressora ao layout do formulário da
caixa de diálogo e à definição do módulo:
1. Clique no controle ComboBox na seção Caixa de ferramentas. Em seguida,
mova o ponteiro para o local no formulário da caixa de diálogo onde o operando
“Nome da Impressora” deve ser colocado. Clique com o botão esquerdo do
mouse novamente para colocar a caixa de combinação no layout do formulário
da caixa de diálogo.
Nota: Neste ponto, o layout do formulário da sua caixa de diálogo não pode se
parecer com o formulário da Figura 3.1. Você aprenderá como organizar os
operandos em“Organizando o layout do formulário de Diálogo” em página 39.
2. Na janela Propriedades do Design, especifique as propriedades da caixa de
combinação selecionada da seguinte maneira:
□ Especifique a propriedade Nome como Nome da impressora. Este é o nome
do operando. Ele será usado na janela lógica para referências de operando
(para fornecer o valor digitado por um modelador em uma instância do
módulo Impressora ao
 lógica subjacente). A propriedade Name é o padrão automático para a
propriedade Text, que é o texto do prompt que é mostrado ao usuário no
formulário da caixa de diálogo.
□ Especifique a propriedade DataType como SymbolName. Isso garantirá
que um modelador usando o módulo Impressora possa especificar apenas
um nome de símbolo válido para o operando Nome da impressora.
□ Especifique a propriedade Necessário como True. Isso exigirá que
qualquer uso de uma instância do módulo Impressora tenha um valor não
em branco para o operando Nome da impressora.
□ Especifique a propriedade InUserView como True. Como o Nome da
impressora é a principal informação relacionada ao módulo Impressora,
exibi-lo na exibição do usuário ajudará o modelador a identificar as
impressoras específicas representadas em um modelo, se mais de um módulo
Impressora for usado.
3. Na janela Propriedades do Design, selecione a propriedade LogicProperties da
caixa de combinação. Essa propriedade fornece uma caixa de diálogo para
especificar características do operando relacionadas à sua finalidade na interface
e na lógica do módulo. Neste exemplo, queremos que o operando Nome da
impressora defina também um elemento de recurso, com base no nome da
impressora. Assim, a caixa de diálogo Logic Properties é preenchida de acordo
com a Figura 3.6.

Figura 3.6 Propriedades lógicas do objeto ComboBox do nome da impressora

Os itens que serão exibidos e disponíveis para seleção na lista suspensa do operando
ComboBox são especificados pela propriedade List da grade Design Properties. Por
padrão, como o operando Nome da Impressora foi especificado como um operando
Elemento, a lista é a lista de elementos de recurso.
TÉCNICO, TEMPO DE MUDANÇA E TEMPO DE IMPRESSÃO
Os três operandos visíveis restantes - Técnico, Tempo de mudança e Tempo de
impressão - são definidos da mesma maneira que o operando Nome da
impressora.
O operando técnico é adicionado usando um controle ComboBox. Esse operando
também define um nome para um recurso e, portanto, na propriedade LogicProperties,
o tipo do operando também é especificado como Elemento do tipo RESOURCES. O
DataType do operando é especificado como SymbolName e sua propriedade Required
é True.
Os operandos Changeover Time e Print Time são adicionados usando os controles
TextBox. Esses dois operandos permitem entradas mais flexíveis e, portanto, suas
propriedades DataType são especificadas como Expressão. Eles são operandos do
tipo Básico na propriedade LogicProperties e não requerem um valor digitado pelo
modelador.

Adicionando operandos do ponto de entrada / saída do

módulo
Além dos quatro operandos visíveis que podem ser vistos e editados pelos usuários
na caixa de diálogo do módulo, dois operandos ocultos serão adicionados à
definição do módulo. Esses operandos serão usados para definir os pontos de
entrada e saída do módulo, que permitem ao usuário conectar outros módulos dentro
e fora do módulo Impressora para fluxo de entidade.
Como os campos do operando do rótulo de entrada e do rótulo de saída estão ocultos
do usuário, o usuário não terá acesso aos campos na caixa de diálogo. No entanto,
pontos de entrada e saída gráficos estarão disponíveis na visualização do usuário do
módulo para colocar as conexões do módulo.
Para adicionar um operando oculto à definição do módulo, clique no controle
HiddenOperand na seção Caixa de ferramentas. Em seguida, mova o ponteiro para
qualquer local no formulário da caixa de diálogo e clique com o botão esquerdo
novamente para adicionar o operando oculto. O operando oculto será exibido em uma
seção da janela na parte inferior do design da caixa de diálogo (e também na árvore
do Operand Explorer), como mostra a Figura 3.7.
 Objeto
HiddenOperand

Figura 3.7 Objeto HiddenOperand na janela de design da caixa de diálogo

Após adicionar dois operandos ocultos ao design da caixa de diálogo e à definição do

módulo, especifique as propriedades Name dos dois operandos como Label e Next
Label. Na propriedade LogicProperties dos operandos, especifique os operandos
como pontos de entrada e saída conforme Figura 3.8 e Figura 3.9.
Figura 3.8 Propriedades lógicas do objeto Label HiddenOperand

Figura 3.9 Propriedades lógicas do objeto Next Label HiddenOperand

Organizando o layout do formulário de Diálogo

Neste ponto, você concluiu a definição dos operandos do módulo Impressora. Os
controles que foram colocados na superfície de um formulário da caixa de
diálogo podem ser selecionados, movidos e redimensionados. Organize os
controles da caixa de combinação e da caixa de texto na impressora
 caixa de diálogo de forma que o layout se pareça com a Figura 3.1. A janela de
design da caixa de diálogo concluída para o módulo Impressora deve ser semelhante
à Figura 3.10 abaixo.

Figura 3.10 Design de caixa de diálogo concluída para o módulo Impressora

Você pode fechar a janela de design da caixa de diálogo clicando no botão Window
Close ou deixar a janela de design da caixa de diálogo aberta para referência
enquanto define a lógica do módulo.

Lógica
A janela lógica
A próxima etapa na criação do módulo Impressora é definir a lógica de modelagem
que entidades serão submetidas durante uma execução de simulação. Essa lógica é
criada projetando um
Submodelo Arena (que consiste em instâncias de módulos de outros painéis de
modelos) na janela lógica da definição do módulo Impressora. Para abrir esta
janela, selecione o item de menu Janela> Lógica ou clique no botão da barra de
ferramentas Janela Lógica na barra de ferramentas Desenvolvimento de Modelo.
As atividades relacionadas à construção da lógica do módulo são
40
.
 fundamentalmente as mesmas que as envolvidas na criação de um modelo de
Arena. Para as instruções apresentadas neste

40
.
Neste tutorial, presumimos que você já esteja familiarizado com as interações
básicas para a construção de modelos no Arena.

Visão geral da lógica do módulo da impressora

Quando um modelador coloca uma instância do módulo Impressora, a lógica
subjacente do módulo será adicionada à janela do modelo. Conforme descrito
anteriormente neste capítulo, o módulo Impressora aceita entidades em uma fila, as
processa através da lógica com recursos e as envia para o próximo módulo ao qual o
módulo Impressora está conectado.
O operando Nome da impressora será usado para estabelecer o nome da fila e o
recurso na lógica subjacente do módulo, para que um modelador possa identificar
áreas diferentes da impressora colocando várias instâncias do módulo Impressora e
fornecendo valores diferentes ao operando Nome da impressora. O nome da fila que
contém entidades antes do processamento fará referência ao operando Nome da
impressora e incluirá uma sequência de texto "_Q" que será anexada ao nome da
impressora, para que o nome da fila seja exclusivo, mas relacionado ao nome do
recurso.
Para capturar a lógica necessária para detectar quando uma troca ocorrerá, uma
variável de simulação é usada. Cada vez que uma entidade realiza uma troca, uma
variável associada à impressora recebe o tipo de trabalho da entidade, indicando o
tipo do último trabalho processado na impressora. Para nomear essa variável,
“_LAST” é anexado ao Nome da impressora (semelhante à convenção de
nomenclatura usada para a fila de impressão). Isso garante que cada impressora
colocada em um modelo tenha uma variável exclusiva associada a ela para armazenar
o último trabalho de impressão processado.
No módulo Impressora, um atributo de entidade chamado Entity.Type é comparado
com a variável que armazena o último trabalho de impressão processado na
impressora para decidir se uma alteração deve ocorrer. Ao projetar o módulo, o nome
do atributo que armazena o tipo de trabalho de impressão pode ter sido adicionado
como um operando do módulo, para que os modeladores possam especificar seus
próprios nomes de atributos. Como optamos por criar essas informações na lógica do
módulo sem permitir que os modeladores alterem o nome do atributo, é necessário
que um modelo contendo o módulo Impressora atribua o atributo denominado
Entity.Type antes de enviar entidades para o módulo Impressora. Isso pode ser feito
automaticamente usando o módulo Create do modelo SIMAN ou Arena e
especificando um tipo de entidade, que atribuirá o atributo interno Entity.Type igual
a esse tipo.
Na seção a seguir, fornecemos uma descrição passo a passo do processo de criação
da lógica do módulo para o módulo Impressora. A Figura 3.11 mostra a conclusão
lógica do módulo. Ao criar o módulo, pode ser útil consultar esta figura para
garantir que você esteja conectando corretamente os módulos na janela lógica.

Figura 3.11 Lógica do módulo da impressora

Entidades receptoras e apreendendo a impressora -

os módulos Fila e apreensão
A primeira instância do módulo na lógica da impressora é o módulo Fila no painel
Blocos do modelo SIMAN. As entidades são criadas primeiro em outro módulo do
modelo, como um módulo Criar. Uma conexão gráfica desse módulo envia entidades
para o módulo Impressora, onde as entidades começam a processar através da lógica
do módulo Impressora neste módulo Fila. Na caixa de diálogo, mostrada na Figura
3.12, você especifica que o nome do módulo Fila é uma referência ao operando
Nome da Impressora digitando o nome do operando entre aspas (ou seja, `Nome da
Impressora '). Nesse caso, o nome da nossa fila terá o "_Q" anexado para que seja
diferente do recurso

42
nome. O campo label da fila, que representa a entrada gráfica no módulo Queue,
contém uma referência ao operando oculto `Label`.

Figura 3.12 Caixa de diálogo Módulo de fila na lógica da impressora

Como alternativa, você pode usar os módulos Estação ou Inserir no painel

Transferência avançada para receber entidades no módulo Impressora. O uso de
estações permite o movimento (com um tempo de atraso opcional) entre áreas, em
vez de conexões gráficas para fluxo lógico.
As entidades do trabalho de impressão permanecerão na fila até que o recurso da
impressora esteja disponível; nesse momento, eles aproveitarão o recurso da
impressora usando um módulo SIMAN Seize. A impressora é apreendida antes de
ser tomada uma decisão sobre uma troca. O módulo foi projetado dessa maneira
para que o recurso da impressora fique indisponível para processar outros trabalhos
de impressão durante uma troca.
Na instância do módulo Aproveitar, você identifica o recurso a ser apreendido
inserindo um único recurso na lista Recursos. Especifique o campo ID do recurso
como `Nome da impressora`. A Figura 3.13 mostra a caixa de diálogo para a
instância do módulo Seize.

Figura 3.13 Caixa de diálogo Capturar módulo na lógica da impressora

Decidir se deseja trocar a impressora - O módulo Decide

O próximo módulo encontrado pelas entidades do trabalho de impressão é um
módulo Decidir (no painel Processo básico) com duas ramificações (o tipo é
bidirecional por condição). A primeira ramificação testa para verificar se o valor do
atributo da entidade Entity.Type difere do último tipo de trabalho processado na
impressora, armazenado em uma variável denominada `Nome da impressora`_LAST.
Nesse caso, as entidades são enviadas para a lógica de troca. A segunda ramificação,
uma condição Else (ou false), envia entidades diretamente para serem processadas na
impressora.
A caixa de diálogo para a instância do módulo Decide é mostrada na Figura 3.14. A
caixa de diálogo é mostrada com a condição de teste para detectar trocas. Para definir
o módulo Decide, use uma condição bidirecional testando a variável `Printer
Name`_LAST
o atributo de entidade Entity.Type, como mostra a Figura 3.14. A condição Else (ou
false) é gerada automaticamente com uma decisão de tipo bidirecional por Condição.

Figura 3.14 Caixa de diálogo Decidir módulo na lógica da impressora

Na janela lógica, a conexão da condição True envia entidades para a lógica de

troca (descrita a seguir). A condição False se conecta diretamente à lógica da
impressora (descrita após a seção de troca).
Nota: Como diferentes entidades no mesmo modelo podem acessar qualquer
caminho da lógica, a decisão sobre a troca é incorporada à lógica do modelo de
simulação, em vez de controlada pela conexão de comutadores aos módulos. Os
comutadores determinam a lógica a ser incluída para todas as entidades. Nos casos
em que diferentes tipos de entidades executam ações diferentes, um módulo como
Decidir (Caminho N por Condição) ou Bloco de Filial do SIMAN deve ser usado. (Os
interruptores são descritos nos capítulos "Visão geral do desenvolvimento de
modelos de arena" e "Janela de comutação".)

Lógica de mudança - Atribuir, processar e

atribuir módulos
A lógica para representar a troca é capturada por três módulos. Primeiro, um módulo
Atribuir (no painel Processo básico) altera o valor da variável `Nome da
impressora`_Alterar, para que as estatísticas possam ser coletadas e a animação possa
representar trocas. Em seguida, um módulo Processo (também no painel Processo
básico) mantém a entidade do trabalho de impressão até que o recurso técnico
especificado na caixa de diálogo Módulo impressora esteja disponível, atrase o
tempo de troca e libere o técnico. Por fim, outro módulo Atribuir restaura o valor da
variável `Printer Name`_Change, para 0 e altera a variável que registra o último tipo
de trabalho de impressão processado na impressora para ser o valor armazenado no
atributo interno Entity.Type da entidade .
A primeira caixa de diálogo Assign module é mostrada na Figura 3.15. Para
definir este módulo de atribuição, insira uma atribuição, mantenha o Tipo padrão
como variável, especifique o nome da variável como 'Nome da
impressora`_Alterar e digite o novo valor 1.

Figura 3.15 Designando variável de troca de impressora na lógica da impressora

Para definir o processo de troca real, você fornece o nome do recurso e as informações
de tempo do processo ao módulo Processo, referenciando os operandos Técnico e de
Tempo de Troca do módulo Impressora, conforme mostrado na Figura 3.16. Você
alterará o campo Ação para Liberação retardada de apreensão para especificar a lógica
para capturar e liberar o técnico especificado durante a troca. Além disso, como o
tempo de mudança é definido como uma expressão, o campo Tipo de atraso é alterado
para Expressão para que o
O operando `Changeover Time` pode ser usado no campo Expression.
Altere as unidades para o atraso das horas padrão para minutos. É importante lembrar
que é consistente com as unidades de tempo entre vários módulos, especialmente se o
usuário final não fornecer as informações das unidades.

Figura 3.16 Caixa de diálogo do módulo de processo na lógica da impressora

O módulo final na lógica de troca é outro módulo Atribuir com duas atribuições: a
variável de troca da impressora e o último tipo de trabalho impresso. Para fornecer
essas informações ao módulo Atribuir, insira duas atribuições. Na primeira
atribuição, selecione a variável (como foi feito no primeiro módulo de atribuição)
para o tipo de atribuição; depois digite `Printer Name`_Altere para o nome da
variável e 0 para o novo valor. Na segunda atribuição, selecione Variável para o tipo
de atribuição
e digite `Printer Name`_LAST para o nome da variável e Entity.Type para o novo
valor, como mostra a Figura 3.17.

Figura 3.17 Atribuindo a última variável de trabalho na lógica da impressora

A lógica de impressão - Módulos de atraso e liberação

Depois que uma entidade de trabalho de impressão conclui a lógica de troca, ela
executa a lógica de impressão real, juntando-se a outras entidades que não foram
processadas pela lógica de troca. O recurso da impressora foi apreendido pela
entidade (independentemente da troca ou não) anteriormente na lógica do módulo
Impressora. Para concluir o processo de impressão, o trabalho de impressão sofre um
atraso de tempo e libera o recurso da impressora usando os módulos Atraso e
Liberação no painel Blocos.
Para especificar o tempo de atraso no módulo Delay, faça referência ao operando do
módulo Print, digitando `Print Time` no campo Duration, como mostra a Figura 3.18.
O SIMAN
O bloco não especifica uma unidade de tempo, como horas ou minutos. As
unidades de tempo padrão dos módulos são definidas posteriormente neste
exemplo, usando o menu Executar> Configuração.

Figura 3.18 Caixa de diálogo do módulo de atraso na lógica da impressora

O módulo Release precisa liberar o recurso da impressora. Para definir isso, insira
um único recurso no módulo Release e defina seu nome como `Printer Name`,
como foi feito no módulo Seize. Como este é o último módulo da lógica, o
operando do ponto de saída, Próximo Rótulo, será referenciado no campo Próximo
Rótulo do Release
 módulo. Isso permite que as entidades fluam do módulo Impressora para o
próximo módulo ao qual está conectado. A Figura 3.19 mostra a caixa de diálogo
para o módulo Release.

Figura 3.19 Caixa de diálogo da instância do módulo Release na lógica da impressora

Como mencionamos anteriormente, o módulo Enter ou Station pode ser usado para
entrar no módulo, em vez de conectar-se ao módulo Queue. Podemos usar um
módulo Rota ou Sair para enviar entidades para outra estação no modelo. Nesse caso,
seria necessário um operando Next Activity para especificar para onde enviar a
entidade em vez de conectar-se a partir do módulo Release. Além disso, o elemento
Stations precisaria ser gerado.

Definindo os elementos do módulo Impressora -

elementos Filas e Variáveis
A etapa final na definição da lógica do módulo Impressora é definir os elementos Filas
e Variáveis associados ao nome da impressora, para que o módulo Impressora defina
completamente a lógica e os elementos necessários para capturar uma estação de
impressão de alta velocidade.

50
.
Para criar a fila `Nome da impressora`_Q, coloque uma instância do módulo Filas
no painel Elementos do modelo SIMAN. No módulo Filas, insira uma única fila e
chame-a de `Nome da impressora`_Q, conforme mostrado na Figura 3.20.

Figura 3.20 Caixa de diálogo do módulo Filas na lógica da impressora

Da mesma forma, a variável `Printer Name`_Change pode ser gerada colocando
uma instância do módulo Variables no painel Elements. No módulo, adicione
uma única variável, chamada `Printer Name`_Change, como mostra a Figura
3.21.

Figura 3.21 Caixa de diálogo do módulo Variáveis na lógica da impressora

52
 O atributo Entity.Type é gerado automaticamente como um dos atributos internos de
todas as entidades quando o tipo de entidade é especificado com um módulo Criar
(no painel Blocos ou Processo básico). Portanto, um módulo de elemento Atributos
não é necessário para definir Entity.Type. No entanto, como esse atributo é usado
para avaliar as entidades recebidas para trocas, a entidade deve ter um valor de tipo
de entidade atribuído antes de entrar no módulo Impressora. Caso contrário, todas as
entidades terão um valor Entity.Type igual a 0 e nenhuma alteração ocorrerá.
A lógica do módulo Impressora agora está completa. Você pode fechar a janela lógica
selecionando a opção Fechar no menu da janela lógica ou pode deixar a janela aberta
enquanto define as duas últimas partes do módulo Impressora - a visualização do
usuário e o ícone do painel.
Nota: Neste exemplo, usamos a janela lógica para criar dois elementos associados à
impressora, a fila e a variável de troca. Esses elementos também podem ser gerados
usando operandos do tipo elemento oculto na janela de design da caixa de diálogo.
Com base nas informações que você deseja fornecer ao usuário para um
determinado elemento, será necessário decidir qual método usar para criar
elementos específicos e suas propriedades. Por favor, consulte o capítulo
"Elementos" para uma discussão mais aprofundada das várias maneiras de definir
elementos.

Visualização do Usuário
A próxima etapa é projetar a visualização do usuário para o módulo Impressora.
Quando um modelador coloca uma instância do módulo Impressora em uma janela
(por exemplo, uma janela de modelo), os objetos adicionados à janela são criados na
janela de exibição do usuário da definição do módulo.
A visualização do usuário para o módulo Impressora conterá seis objetos:
 uma alça de módulo,
 um operando exibido (o Nome da impressora),
 um ponto de entrada para conectar a lógica ao módulo,
 um ponto de saída para conectar a lógica ao módulo,
 um recurso de animação e
 uma imagem global de animação.
O Arena coloca automaticamente os quatro primeiros objetos na janela de exibição
do usuário. Cada módulo recebe um identificador de módulo que exibe o nome do
módulo (por padrão). Em uma instância do módulo Impressora, um modelador
clica duas vezes no identificador para abrir a caixa de diálogo principal. Arena
coloca o operando exibido na janela de exibição do usuário depois que o operando
Nome da impressora foi definido com a propriedade InUserview especificada
como True (na janela de design da caixa de diálogo). Os pontos de entrada
e saída são colocados automaticamente quando um operando é do tipo
Ponto de entrada ou Ponto de saída.
Para concluir a visualização do usuário, você adicionará um recurso de animação
para exibir o estado da impressora durante uma execução de simulação e uma
imagem global de animação para exibir um símbolo durante o processo de troca.
Para abrir a janela de visualização do usuário, selecione o item de menu Janela>
Visualização do usuário ou clique no botão da barra de ferramentas Visualização do
usuário na barra de ferramentas Desenvolvimento de modelo. A visualização do
usuário para o módulo Impressora deve aparecer como mostrado na Figura 3.22.

Figura 3.22 Janela de visualização inicial do usuário para o módulo Impressora

Para adicionar um recurso de animação, coloque a imagem do recurso (na barra de

ferramentas Animar) acima do nome do identificador do módulo Impressora e clique
duas vezes nele para abrir a caixa de diálogo Recurso de animação. Nesta caixa de
diálogo, especifique o identificador do recurso como `Nome da impressora`, para
que o nome do recurso de animação corresponda ao recurso definido quando um
modelador usa o módulo Impressora.
O módulo Impressora precisa de duas figuras para que o recurso represente os
estados Inativo e Ocupado. Você especifica os estados dos recursos e desenha as
figuras da mesma forma que nos modelos de Arena.
A Figura 3.23 mostra a caixa de diálogo de imagem de recurso concluída para o
módulo Impressora.

Figura 3.23 Caixa de diálogo de imagem do recurso de animação

Por fim, adicione uma imagem global animada à esquerda do recurso usando o botão
Global na barra de ferramentas Animar. Especifique a expressão como `Nome da
impressora`_Alterar (a variável atribuída a 1 durante uma troca). O valor do
acionador para o global deve ser 1, para que a imagem que você coloca apareça
somente quando a mudança estiver ocorrendo. Quando o valor da variável `Printer
Name`_Change for definido como 0 (após a conclusão da troca), o símbolo global
desaparecerá, pois não
 A imagem é especificada para um valor de disparo igual a 0. A Figura 3.24 mostra
a imagem global completa.

Figura 3.24 Caixa de diálogo Global Picture Animation

A imagem global é usada em vez de animar o recurso `Technician` que realiza a

troca. Isso é feito porque o técnico pode ser solicitado a realizar trocas em vários
módulos de impressora diferentes no modelo. O símbolo global mostrará a imagem
de um técnico somente quando a troca estiver ocorrendo naquele módulo específico
da impressora.

Ícone do painel
O ícone do painel de um módulo é a imagem que aparece no painel quando um
arquivo de painel de modelo é anexado a uma janela de modelo (ou à janela lógica da
definição de outro módulo). Ele é desenhado em uma janela semelhante à janela de
edição de imagem usada para criar recursos de animação, entidades e assim por
diante.
 Para o módulo Impressora, você pode copiar os objetos do recurso de animação
Imprimindo imagem (na visualização do usuário) para a janela do ícone do painel
usando a área de transferência. Para fazer isso, edite a imagem associada ao estado
Ocupado do recurso de animação, selecione todos os objetos e copie-os para a área
de transferência. Em seguida, abra a janela do ícone do painel selecionando o item de
menu Janela> Ícone do painel ou clicando no botão da barra de ferramentas Ícone do
painel na barra de ferramentas Desenvolvimento de modelos. A janela do ícone do
painel contém um único objeto de texto, por padrão, que exibe o nome do módulo.
Para adicionar os gráficos da imagem do recurso de animação, cole-os da área de
transferência na janela do ícone do painel. O nome do módulo, Impressora, é
mostrado inicialmente como apenas as quatro primeiras letras, "Prin". Clique duas
vezes no nome para que você possa alterá-lo para a palavra inteira “Impressora.

Figura 3.25 Janela de ícone do painel para o módulo Impressora

Um modelo de amostra
Preparando o modelo para uso
Agora você concluiu a definição de um módulo que representa uma estação de
impressora de alta velocidade. Seus operandos permitem que o modelador
personalize certas características da impressora, a lógica do módulo subjacente
captura os aspectos críticos das operações da impressora, a visualização do usuário
fornece uma animação para ajudar os modeladores a entender o comportamento dos
sistemas que incluem uma impressora e o ícone do painel é concluído. o pacote.
 O módulo Impressora faz parte de uma biblioteca de painéis de modelos. Se você
ainda não salvou seu painel de modelos em um arquivo de biblioteca, faça isso agora
selecionando o item de menu Arquivo> Salvar na barra de menus principal ou
clicando no botão Salvar na barra de ferramentas Padrão. Você pode selecionar um
nome como HSPrint.tpl para o arquivo.
A próxima etapa é gerar um arquivo de objeto do painel de modelo (.tpo) que possa
ser anexado ao a barra do projeto. Selecione o item de menu Verificar> Gerar TPO no
menu principal
barra ou clique no botão Gerar barra de ferramentas. Isso inicia uma verificação dos
módulos do arquivo do painel de modelos (neste caso, apenas o módulo Impressora)
para verificar se os operandos referenciados por objetos nas janelas de definição de
módulo estão definidos na janela de design da caixa de diálogo, os operandos
referenciados no usuário janela de visualização são definidas e assim por diante
Se você seguiu corretamente as instruções para criar o módulo Impressora, receberá
uma mensagem informando que o arquivo .tpo foi gerado com êxito. No entanto, se
a definição do seu módulo contiver um erro, uma janela de erro do Arena será
exibida contendo uma descrição do erro. Por exemplo, se você digitou
incorretamente a referência do operando (`Print Time`) no módulo Delay da janela
lógica como` Printing Time ', a mensagem de erro “Operando referenciado não
definido:' Printing Time`” é exibida na janela de erro. Você pode usar o botão Editar
para corrigir o erro; abre a janela apropriada (neste caso, a janela lógica) e exibe a
caixa de diálogo para o objeto que contém o erro (ou seja, a instância do módulo
Delay). Você pode digitar a correção na caixa de diálogo, selecionar OK e gerar o
arquivo .tpo.
Os avisos, por outro lado, não precisam ser resolvidos. O arquivo .tpo será gerado
com êxito, independentemente de você optar por abordar os avisos. Obviamente, isso
não tem nada a ver com a correção da definição do seu módulo; a
.tpo O arquivo ainda será gerado com sucesso.
Após a geração bem-sucedida de um arquivo de objeto do painel de modelo, você
pode usar o módulo Impressora em um modelo de simulação para testar sua
lógica, animação e assim por diante. Na seção a seguir, apresentamos um modelo
simples contendo uma única impressora.

Modelo de simulação de impressora única

Nosso modelo de simulação de amostra criará dois tipos de trabalhos de impressão
usando dois módulos Criar. O atributo interno Entity.Type receberá valores da
Entidade 1 e 2, respectivamente. Os trabalhos de impressão serão enviados para um
módulo Impressora para serem processados, conectando cada módulo Criar ao
módulo Impressora. Depois que os trabalhos concluem o processo de impressão, eles
são enviados para o módulo Dispose que remove as entidades do trabalho de
impressão do sistema. Para ajudar a verificar se a lógica da impressora está
funcionando corretamente, usaremos valores constantes para os tempos de chegada
das entidades e para os dois atrasos que podem ocorrer na impressora (o tempo de
troca e o tempo de impressão). Podemos
calcule os valores esperados para estatísticas, como a porcentagem de tempo que
cada recurso deve ficar em cada um de seus estados (ocupado e ocioso), depois
execute uma simulação piloto e compare os resultados com os valores esperados.
A Figura 3.26 mostra o modelo completo; siga as instruções passo a passo para a
construção do modelo.

Figura 3.26 Modelo de simulação de amostra usando o módulo Impressora

GERANDO ENTIDADES DE TRABALHO DE IMPRESSÃO - O

MÓDULO CRIAR
Para construir o modelo, comece abrindo uma nova janela do modelo. Os dois
primeiros módulos a serem colocados são Criar módulos no painel Processo básico
da Arena, que é anexado automaticamente. Coloque duas instâncias do módulo
Create no modelo; o primeiro gerará trabalhos da Entidade 1 e o segundo, trabalhos
da Entidade 2.
Para definir as características das chegadas de tarefas da Entidade 1, edite o primeiro
módulo Criar. Nomeie o módulo Entidade 1 Jobs e especifique que o tempo entre
chegadas é constante com o valor de 1 minuto. A segunda instância do módulo Create
requer informações semelhantes. Digite um nome, Entidade 2 Trabalhos, o tempo
entre as chegadas é constante, chegando a cada 10 minutos. Altere o campo Tipo de
entidade para Entidade 2 e
 altere o tempo padrão de criação da primeira entidade de 0,0 para 10 minutos. As
Figuras 3.27 e Figura 3.28 mostram os módulos Criar para cada tipo de entidade.

Figura 3.27 Caixa de diálogo Criar módulo para tarefas da Entidade 1

Figura 3.28 Caixa de diálogo Criar módulo para tarefas da Entidade 2

PROCESSANDO OS TRABALHOS DE IMPRESSÃO - O

MÓDULO DA IMPRESSORA
Para usar o módulo Impressora que você definiu, é necessário anexar um segundo
painel - o arquivo de objeto do painel de modelo que você gerou - à Barra do
Projeto. Anexe o painel e selecione o arquivo .tpo que você nomeou anteriormente
(por exemplo, HSPrint.tpo).
Nota: Se o arquivo que você criou não aparecer na lista, você poderá ter esquecido
de gerar o arquivo.arquivo tpo após corrigir erros. Abra a janela do modelo e clique
no botão Gerar na barra de ferramentas para criar um arquivo de objeto do painel
de modelos.

60
O painel do modelo deve conter um único ícone, o ícone do painel que você
desenhou para representar o módulo Impressora, como mostra a Figura 3.29.

Figura 3.29 Painel Modelo com o ícone do painel Módulo da impressora

Coloque uma instância do módulo Impressora na janela do modelo e edite-a clicando

duas vezes na alça do módulo Impressora. A Figura 3.30 mostra a caixa de diálogo do
módulo Impressora concluída.
No módulo Impressora, digite o Nome da impressora como HSPrinter 1. Isso criará
automaticamente um recurso chamado HSPrinter 1 e o colocará na lista de recursos.
Ele também fornecerá as informações para os módulos Apreender e Liberar na lógica
subjacente. Este nome fornecerá nomes para a fila (HSPrinter 1_Q) e variáveis
HSPrinter1_LAST e HSPrinter_Change.
Digite um nome para o campo Técnico, Changeover Tech. Isso também criará um
recurso e o colocará na lista de recursos. A tecnologia de mudança será o recurso
usado no módulo de processo na lógica subjacente para executar a mudança.
Por fim, especifique que o tempo para realizar uma troca é de 0,2 minutos e o tempo
de impressão é de 0,5 minutos.

Figura 3.30 Caixa de diálogo da instância do módulo da impressora

TRABALHOS DE IMPRESSÃO CONCLUÍDOS - O MÓDULO DE
ELIMINAÇÃO
A última parte da lógica do modelo é um módulo Dispose no painel Basic Process.
Coloque um módulo Dispose, que descartará as entidades do trabalho de impressão
(trabalhos da Entidade 1 e Entidade 2).
PROJETO DE SIMULAÇÃO E INFORMAÇÃO DO
COMPRIMENTO DA EXECUÇÃO - A EXECUÇÃO> MENU DE
CONFIGURAÇÃO
Antes de iniciar uma execução de simulação, selecione a opção Executar>
Configuração. As guias Parâmetros do projeto e Parâmetros de replicação
permitem identificar as informações do projeto e estabelecer um comprimento de
execução. Para a execução do piloto, a duração da execução da simulação é
arbitrária, pois foram utilizados tempos constantes para tempos de chegada e
atraso; insira um valor 8 para o Comprimento da replicação para simular um dia
útil de oito horas. Altere o campo Unidades de tempo base para minutos, pois os
tempos de chegada, mudança e impressão da entidade são especificados em
minutos.
Além disso, como o início da simulação incluirá uma troca extra (para inicializar a
impressora para imprimir trabalhos do Tipo 1), especifique um período de
aquecimento de 10 minutos. Ao iniciar a coleta de estatísticas no tempo 10, a
execução da simulação incluirá ciclos previsíveis de processamento de 11 entidades
em ciclos de 10 minutos (ou seja, 10 tarefas da Entidade 1 e uma tarefa da Entidade
2). Com um tempo de troca de 0,2 minutos, podemos prever que o técnico de troca
será usado 4% do tempo. Isso é calculado por duas alternâncias (a 0,2 minutos por
alternância) a cada 10 minutos (uma alternância para a Entidade 1, outra para a
Entidade 2) com um tempo total de 0,4 a cada 10 minutos. Com um tempo de
impressão de 0,5 minutos, podemos prever que a porcentagem de tempo em que a
impressora está realmente imprimindo deve ser de 55% (ou seja, deve haver 5,5
minutos - 11 * 0). 5 - de impressão a cada 10 minutos de simulação). Lembre-se de
que o recurso da impressora também está ocupado durante a troca (ou 4%); portanto,
o tempo total de ocupado (incluindo impressão e troca) deve ser de 59%.
VERIFICANDO A LÓGICA DO MÓDULO
Para testar a lógica do módulo Impressora, é útil percorrer o modelo de simulação
para os primeiros eventos (usando o botão Etapa na barra de ferramentas Executar),
assim como você pode fazer para verificar um modelo criado usando módulos de
outros painéis de modelos .
O primeiro evento na execução da simulação será a chegada de uma entidade de
trabalho da Entidade 1. O valor inicial da variável que armazena o último tipo de
trabalho processado na impressora é 0, o valor inicial padrão para qualquer variável

62
de uso geral. À medida que você avança no processamento da primeira entidade,
deve ocorrer um evento de mudança (a imagem de animação da imagem global deve
mostrar a Tecnologia de mudança durante a transição) para configurar a impressora
para processar os trabalhos da Entidade 1. Após a conclusão da troca, a variável de
tipo de trabalho muda para um valor de 1. A imagem do recurso é exibida durante o
tempo de troca e impressão, pois não está disponível durante o processo.

63
Muda com o tempo. A Figura 3.31 mostra a animação do módulo Impressora
durante a primeira troca.

Figura 3.31 Animação do módulo Impressora durante a primeira troca

No restante da simulação, você verá um ciclo de trocas para a Entidade 1,

processamento de tarefas da Entidade 1, trocas para a Entidade 2, processamento de
tarefas da Entidade 2 e assim por diante. No final da simulação, você será perguntado
se deseja visualizar os resultados da simulação. O relatório Visão geral da categoria é
gerado para mostrar informações gerais sobre entidades, filas e recursos. Esses
relatórios podem ser visualizados usando as setas na parte superior da janela.
Relatórios adicionais podem ser selecionados no painel Relatórios, incluindo
relatórios de entidades, filas e recursos.
Como esperado, o recurso da impressora estava ocupado 59% do tempo, o que incluía
4% do tempo para trocas (ou seja, duas trocas de duração .2 minutos para cada 10
minutos de simulação); e ficou ocioso com os 41% restantes da corrida. A Figura 3.32
mostra o primeiro relatório de Recursos mostrando o Resumo dos detalhes do recurso
na execução da simulação.
 Figura 3.32 Relatório de recursos mostrando o resumo de detalhes do recurso

Sumário
Você definiu um módulo de simulação completo, o módulo Impressora, que captura
a lógica associada a uma área de impressão de alta velocidade e permite que um
modelador forneça valores que definem características críticas de um processo de
impressão. Este módulo pode ser usado na construção de modelos de simulação.
Você também pode anexar seu arquivo de objeto do painel de modelos à Barra de
Projetos e usá-lo na janela lógica da definição de outro módulo para criar novos
painéis de modelos.
4 A janela Modelo
Os recursos de desenvolvimento de modelos da Arena se concentram no design e
criação de modelos que consistem em módulos. Esses módulos podem ser usados em
modelos de simulação, colocando-os nas janelas do modelo Arena, ou na definição
de outros módulos, colocando-os nas janelas lógicas de outras definições de módulo.
Um painel de modelos é um arquivo que contém uma biblioteca de definições de
módulos. A janela do modelo, exibida através da criação de um novo documento de
modelo ou da abertura de um documento existente, é uma janela base a partir da qual
novos módulos são definidos. Na barra de ferramentas Desenvolvimento de modelo,
você pode acessar as cinco janelas de definição de módulo - design da caixa de
diálogo, lógica, comutador, visualização do usuário e ícone do painel - que
constituem um módulo.
Os mecanismos usados para definir os módulos em um arquivo de painel de modelo
são descritos nos capítulos: Janela Design de Diálogo, Janela Lógica, Janela User
View, Janela Switch e Janela Ícone do Painel. Este capítulo descreve as opções e
ações fornecidas pela janela do modelo.

O menu do modelo
Criando uma nova janela de modelo
A primeira etapa na criação de um painel de modelo é abrir uma nova janela de
modelo, selecionando Arquivo> Novo na barra de menus principal e selecionando
a opção Janela de modelo. Quando você abre uma janela de modelo, a barra de
ferramentas Desenvolvimento de Modelo é exibida. Uma nova janela de modelo é
mostrada na Figura 4.1.

65
Figura 4.1 Janela Novo modelo

66
UMARENA TEMPLATE DEVELOPER"S
GUIDE

Dentro da janela do modelo, há duas entradas: a versão do modelo e a lista de

módulos contidos no arquivo do painel de modelos. A lista Definições do módulo é
usada para nomear novas definições de módulo e identificar o módulo existente
cujas janelas de definição de módulo devem ser abertas.

Carregando um arquivo de painel de modelo existente

Para carregar um arquivo do painel de modelos existente, selecione o item de
menu Arquivo> Abrir na barra de menus principal. Especifique para listar os
arquivos do tipo Modelo (* .tpl).

Fechando um modelo
Se você terminou de trabalhar com um arquivo de painel de modelo, ative a janela de
modelo e selecione a opção de menu Arquivo> Fechar. Se você tiver alterado as
definições de qualquer módulo no painel de modelos desde a última vez que o salvou,
você será avisado caso queira primeiro salvar as alterações. Quando a janela do
modelo é fechada, todas as janelas de definição de módulo que foram deixadas
abertas também serão fechadas.

Salvando o arquivo de biblioteca do painel de modelos

Para salvar o arquivo .tpl, escolha Arquivo> Salvar na barra de menus principal.

Criando e editando módulos

A lista de definições do módulo
Para nomear uma nova definição de módulo, clique no botão Adicionar, digite o
nome desejado e pressione OK. (Consulte a Figura 4.1 para obter uma janela de
modelo de amostra.) Para renomear um módulo a qualquer momento, realce o nome
do módulo e clique no botão Editar. Uma caixa de diálogo é aberta solicitando o
novo nome do módulo. Duas caixas de seleção (Módulo Necessário e de Dados), um
campo para Operando Nome e um botão Definições do Construtor de Expressões
também estão na caixa de diálogo de definição do módulo. Por favor see “Opções de
modelo” na página 71 para mais informações sobre esses itens.
Para excluir um módulo do arquivo do painel de modelos, destaque o módulo e
pressione o botão
Excluir botão. Uma caixa de diálogo será aberta solicitando que você confirme a
exclusão.
Para reordenar as definições de módulo existentes, use as setas CTRL + Up e CTRL +
Down
UMARENA TEMPLATE DEVELOPER"S
GUIDE pressionamentos de tecla de seta para mover o módulo destacado para cima ou para
baixo na lista, respectivamente.
Nota: A ordem em que os módulos serão exibidos em um painel (quando o painel de
modelos estiver anexado à Barra de Projetos) é definida pela ordem em que
aparecem na lista Definições de módulos.
 Abrindo Janelas de Definição do Módulo
Cada módulo possui cinco janelas de definição de módulo associadas: design da
caixa de diálogo, lógica, comutador, visualização do usuário e ícone do painel.
Para abrir uma das janelas de definição de módulo, realce o módulo na lista e
escolha a janela de definição que deseja abrir na opção de menu Janela ou
pressione o botão da barra de ferramentas para a janela desejada. A Figura 4.2
mostra os cinco botões da barra de ferramentas que abrem as janelas de definição
de módulo.

Figura 4.2 Barra de ferramentas de desenvolvimento de modelos com os botões

Design de Diálogo, Lógica, Switch, User View e Panel Icon

Por exemplo, para abrir a janela lógica de um módulo específico, realce o nome do
módulo e escolha a opção de menu Janela> Lógica ou pressione o botão da barra de
ferramentas Janela Lógica na barra de ferramentas Desenvolvimento de modelos.

Preparando o painel de modelos para uso

Verificando se há erros e avisos no painel de modelos
Para verificar se há possíveis erros nos módulos em um painel de modelos, escolha
a opção de menu Verificar> Modelo na barra de menus principal ou pressione o
botão Verificar barra de ferramentas na barra de ferramentas Desenvolvimento de
modelos. Todos os erros detectados no painel do modelo serão exibidos na janela
Erro.
Os avisos e erros criados pela verificação dos painéis do modelo são exibidos usando
os mesmos mecanismos dos avisos e erros causados quando um modelo é verificado.
Nota: A gerar.A etapa tpo (descrita mais adiante nesta seção) verifica
automaticamente o painel de modelos. Se forem encontrados erros, os
procedimentos descritos abaixo se aplicam se foram descobertos durante a geração
de um arquivo .tpo ou a partir de uma seleção de modelo de verificação.

Sempre que possível, o Arena o ajudará a localizar e corrigir o erro quando você
clicar no botão Localizar ou Editar na janela Erro. Se você clicar no botão Localizar,
a janela de definição do módulo que contém o objeto que causou o aviso ou erro será
ativada e a construção será destacada. Por exemplo, se você referenciou um operando
Order Size na janela lógica de um módulo, mas não definiu o operando, o Arena
emitirá uma mensagem de erro nesse sentido, conforme ilustrado na Figura 4.3.
Nisso
Nesse caso, você pode usar o botão Localizar para abrir a janela lógica e localizar o
módulo que referenciou o Tamanho do pedido. O botão Editar executa a mesma
função que Localizar, mas, além de localizar o objeto, também abre a caixa de
diálogo do objeto que causou o erro ou aviso, para que você possa corrigi-lo
diretamente.

Figura 4.3 Painel Modelo Mensagem de erro de verificação

Nota: Se nenhum erro for detectado quando o painel do modelo estiver marcado,
uma mensagem nesse sentido será exibida. Clique em OK para fechar a caixa de
mensagem.

Analisando erros
Se você deseja revisar os erros que já foram relatados em uma janela de Erro,
escolha a opção de menu Verificar> Revisar erros na barra de menus principal. Esta
função recupera apenas mensagens de erro geradas anteriormente; não irá verificar
novamente o painel do modelo. Se você fez alterações no painel de modelos desde a
última vez em que foi verificado, verifique novamente o painel de modelos antes de
revisar os erros.

Relatórios de arquivo do painel Modelo

O Arena fornece relatórios resumidos dos nomes e posições dos objetos na janela
de design da caixa de diálogo e as definições dos comutadores para as definições
do módulo em um arquivo de painel de modelo. (Consulte os capítulos “A janela
de design da caixa de diálogo” e “A janela da central” para obter uma descrição dos
operandos e centrais.) Esses relatórios podem ajudá-lo a projetar caixas de diálogo
e a validar a definição de centrais complexas.
módulos. Para visualizar esses relatórios, escolha a opção de menu Verificar>
Relatório na barra de menus principal. A caixa de diálogo do relatório é aberta,
como mostra a Figura 4.4.

Figura 4.4 Caixa de diálogo Relatório do painel Modelo

Você pode optar por exibir o operando ou alternar o relatório; você também pode
mostrar um relatório para todos os módulos no arquivo do painel de modelos ou para
um único módulo. Os relatórios solicitados são exibidos em uma janela de texto
rolável. Você pode salvar o conteúdo do relatório em um arquivo de texto,
selecionando o item de menu Arquivo> Salvar (que aparece na janela de texto) ou
pode imprimir o relatório usando o item Arquivo> Imprimir.
RELATÓRIO DE OPERAÇÕES E POSIÇÕES
O relatório Posições do operando contém uma lista de todos os operandos, grupos de
repetição e caixas de diálogo em uma tabela, fornecendo seus locais de exibição na
caixa de diálogo do módulo. Operandos ocultos são designados com (HD) seguindo
seus nomes, grupos de repetição com (RG) e caixas de diálogo com (DB). A Figura
4.5 mostra um exemplo de relatório de posições de operando.
 Figura 4.5 Relatório de exemplo de posições de operando

RELATÓRIO OPERANDO
O relatório Prompts do Operando lista os nomes dos operandos e seus prompts
associados. Este relatório deve ser fornecido aos usuários do modelo para uso com a
função Importação de dados do módulo> Exportar.

70
 RELATÓRIO DO INTERRUPTOR
O relatório Switch lista os nomes e definições do switch, conforme ilustrado na Figura
4.6.

Figura 4.6 Relatório de amostra de switch

Gerando o arquivo de objeto do painel de modelo (.tpo)

Depois que um arquivo do painel de modelo é salvo e verificado, é possível usar seus
módulos para construir um modelo ou definir a lógica na definição de um novo
módulo. Antes que isso ocorra, você deve gerar o arquivo de objeto do painel de
modelo, que pode ser anexado à Barra de Projetos para uso em um modelo ou janela
lógica. Para criar o arquivo de objeto do painel de modelo (ou .tpo), escolha a opção
de menu Verificar> Gerar TPO na barra de menus principal ou pressione o botão
Gerar na barra de ferramentas. Antes de criar o arquivo .tpo, essa função verificará o
arquivo do painel do modelo e reportará os erros encontrados. Se não houver erros, o
arquivo .tpo será criado e uma mensagem para esse efeito será emitida.
Nota: Após um objeto do painel de modelo (.tpo) foi gerado, o arquivo .tpl não é
necessário para criar modelos; somente o arquivo .tpo é necessário. Se você for
fornecer seu painel de modelos para outro usuário do Arena, precisará distribuir o
arquivo .tpo.

Outras informações do painel de modelos

Alterando a versão
A entrada Versão na janela do modelo foi projetada para ajudá-lo a registrar as
atualizações que você pode fazer nos painéis de modelos criados.

Opções de modelo
Várias características adicionais dos painéis de modelos podem ser alteradas usando
a caixa de diálogo Opções de modelo. Para abri-lo, selecione o menu Editar>
Opções de modelo
item da barra de menus principal. A caixa de diálogo Opções de modelo é aberta,
como mostra a Figura 4.7.

Figura 4.7 Caixa de diálogo Opções do modelo

ALTERANDO O NOME DO DISPLAY DE MODELO

Por padrão, os painéis anexados à Barra de Projeto exibem um rótulo na barra de
título do painel correspondente ao nome do arquivo fornecido para o arquivo de
objeto do painel de modelo (.tpo). Você pode alterar o nome exibido no painel
digitando o novo rótulo no campo Nome para exibição do modelo e escolhendo OK.
Nota: Alterar o nome para exibição não modifica o nome do.arquivos tpl / .tpo;
fornece uma nova sequência de texto a ser exibida na parte superior do painel.

CRIANDO PAINÉIS DE MODELO “PRIVADOS”

Você pode criar um painel de modelo que deve ser usado apenas na criação de outros
modelos, não na criação de modelos de simulação. Nós nos referimos a esse tipo de
painel de modelo como um painel "privado". Para tornar um painel de modelo
privado, selecione a opção Privado na caixa de diálogo Opções de modelo e escolha
OK. Se você distribuir um painel de modelos contendo uma definição de módulo que
tenha um painel privado conectado, também deverá fornecer o arquivo .tpo do painel
de modelos privados. O arquivo utlarena.tpo que é distribuído com o Arena é um
painel privado. É descrito no capítulo "A janela lógica".

72
ALTERAÇÃO DO VISOR PADRÃO DO PAINEL
A exibição padrão dos módulos no painel do modelo pode ser alterada para cada
modelo que você criar. Você pode definir a exibição padrão como Ícones grandes,
Ícones pequenos ou Somente texto. Depois de anexar o painel de modelos à Barra
de Projetos, você pode alterar essa configuração clicando com o botão direito do
mouse enquanto passa o mouse dentro da Barra de Projetos e selecionando a opção
desejada no menu de atalho. Por padrão, ícones pequenos e grandes são exibidos em
duas colunas e somente texto é exibido em uma única coluna. A exibição pode ser
alterada arrastando a barra divisória entre a Barra do projeto e a janela do modelo
para uma largura diferente.
ALTERAR AS OPÇÕES DE AJUDA DO MÓDULO
Esta opção determina qual tópico da ajuda será exibido quando o usuário escolher o
botão Ajuda e, em seguida, clicar no módulo no painel do modelo em vez de editar o
módulo e clicar no botão Ajuda na caixa de diálogo do módulo. Se Itens de Ajuda
Separados estiver selecionado, as duas ações descritas acima exibirão dois tópicos de
ajuda diferentes. Isso pode ser desejável se você desejar fornecer uma breve
descrição em um tópico e informações mais detalhadas no outro. Se, no entanto, Item
de Ajuda Comum estiver selecionado, a execução das ações descritas acima exibirá o
mesmo tópico de ajuda único.
OPÇÃO DE ORDEM DE EXPORTAÇÃO
A caixa de diálogo Exportar Classificação é usada para definir a ordem na qual os
módulos são gravados quando uma Exportação de Dados do Módulo é realizada.
Todos os módulos no modelo estão contidos nas duas listas: módulos não
classificados e módulos classificados. Inicialmente, todos os módulos estão na lista
não classificada.
Para criar uma lista classificada de módulos, realce cada módulo na lista não
classificada que você deseja classificar e clique no botão Adicionar para mover o (s)
módulo (s) para a lista classificada. O botão Remover move os módulos destacados
na lista classificada de volta para a lista não classificada.
Na lista classificada, use os botões Para cima e Para baixo para mover o módulo
realçado para cima ou para baixo.
Consulte os tópicos da Ajuda no recurso Transferência de dados do módulo para obter
mais informações.

Definindo Módulos Necessários

Os botões Adicionar e Editar na janela do modelo ativam uma caixa de diálogo
usada para definir um novo nome para um módulo, como mostra a Figura 4.8.
Também indica se um
O módulo será necessário em qualquer modelo que o utilize. Se a caixa de
seleção Requerido estiver marcada, o módulo será definido como
"obrigatório".

Figura 4.8 Caixa de diálogo Module Definition

Se um painel de modelo contiver um módulo necessário e se algum módulo do

modelo for colocado em um modelo, pelo menos uma instância do módulo
necessário também deverá ser colocada no modelo. Você pode usar esta opção para
criar uma definição de módulo que solicite ao usuário parâmetros de execução ou
que contenha lógica especial que entidades podem ser enviadas para executar por
outros módulos no modelo.

Definindo Módulos de Dados

Outra opção na caixa de diálogo Definição de módulo de um módulo, exibida
quando você clica nos botões Adicionar ou Editar na janela Modelo, é a capacidade
de marcar o módulo como um módulo de dados. Ao contrário de outros módulos
(conhecidos como módulos lógicos), os módulos de dados não são colocados na
janela do modelo usando o recurso de arrastar e soltar. Em vez disso, elas são
adicionadas apenas à planilha clicando duas vezes nas palavras da planilha "Clique
duas vezes aqui para adicionar uma nova linha".
Outra característica dos módulos de dados é que eles podem ser criados
automaticamente por módulos lógicos. Para obter mais informações sobre o
recurso criado automaticamente, consulte“Criação automática módulos ”na
página 96.

Definindo um operando de nome

Outra opção na caixa de diálogo Definição de módulo de um módulo é o campo
Operando de nome. Se você escolher um operando de um módulo a ser designado
como o Nome do módulo
Operando, o Arena aplicará exclusividade para o valor desse operando. Por
exemplo, se um módulo chamado Process define um operando chamado Process
Name como seu Operando Name, um usuário que constrói um modelo com vários
módulos Process deve fornecer Nomes de Processos exclusivos ou ocorrerá um
erro.)
Embora esteja disponível para os módulos lógicos e de dados, o campo Nome do
operando é particularmente útil para os módulos de dados, principalmente em
conjunto com a opção Criação automática de outro módulo. Se um operando de outro
módulo cria automaticamente um módulo de dados, o valor do operando é passado
para o Operando de Nome do módulo de dados. Por exemplo, se um módulo de
dados chamado Recurso tiver um Operando de Nome chamado MyName e outro
módulo chamado Process tiver um operando ResName que crie automaticamente o
módulo de dados do Recurso, o valor do ResName do módulo de Processo será
passado para o operando MyName do módulo de Recurso .
O operando especificado no campo Nome do Operando deve primeiro ser definido
na janela de design da caixa de diálogo. Além disso, ele deve estar visível
(geralmente, é exibido na planilha) e não pode ser repetido. Caixas de diálogo e
grupos de repetição não podem ser especificados neste campo.

Definições do Construtor de Expressões

O botão Definições do Construtor de Expressões abre uma caixa de diálogo que
permite definir cadeias de caracteres do construtor de expressões para a definição do
módulo. As cadeias de expressão estarão disponíveis na visualização em árvore do
Expression Builder se uma instância do módulo for colocada no modelo.
Consulte os tópicos da Ajuda “O Expression Builder” e “Expression Builder
Definitions” para obter mais informações.

Criando cópias das definições do módulo

A área de transferência pode ser usada para duplicar uma definição de módulo, para
que uma variação de um módulo existente possa ser criada rapidamente. Para copiar
uma definição de módulo inteira, realce o módulo na janela do modelo e clique em
Editar> Copiar ou pressione o botão Copiar na barra de ferramentas. Para colar o
módulo em qualquer janela de modelo, destaque a posição desejada na lista
Definições do módulo e clique na opção de menu Editar> Colar ou clique no botão
Colar da barra de ferramentas. O módulo será colado na posição destacada no
momento. Se um módulo com o mesmo nome já existir na janela do modelo, o novo
módulo será renomeado com um sublinhado anexado ao nome.

Compatibilidade de instâncias de módulos existentes

Se você possui arquivos de modelo (.doe) ou arquivos de painel (.tpl) existentes que
contêm instâncias de módulos de um modelo em que está trabalhando, poderá carregar
o
arquivos .doe / .tpl, mesmo que você faça alterações no design da caixa de diálogo
ou alterne as janelas das definições de módulo. Por exemplo, se você tiver um
arquivo de painel de modelo, bank1.tpl, contendo módulos denominados Clientes,
Caixas, ATM e Gerente e um arquivo de modelo, cityhq.doe, contendo instâncias
dos módulos Clientes e Caixas, você ainda poderá carregue o arquivo de modelo
mesmo se você alterar a definição do módulo Customers ou Caixas (alterando as
janelas de design da caixa de diálogo, lógica, comutador, visualização do usuário ou
ícone do painel).
Exemplos de alterações que você pode fazer nos módulos existentes incluem:
adicionar novos operandos, remover operandos obsoletos, alterar tipos de operandos
de Element para Basic (ou de qualquer tipo para outro tipo) e alterar dados repetíveis
em dados não repetíveis (removendo o repetir objeto de grupo). Nós fazemos todos
os esforços para usar os dados nos operandos existentes com a nova estrutura do
módulo. No entanto, os dados em operandos obsoletos serão descartados.
Ao criar um módulo e alternar entre editar a definição e colocar o módulo em um
modelo de simulação (para testá-lo), recomendamos que você trabalhe com uma
nova janela de modelo sempre que modificar o arquivo do painel de modelo. Ou, se
você estabeleceu uma janela de modelo e deseja reter os outros módulos que você
colocou, exclua as instâncias do módulo que são do painel de modelos e desanexe o
painel de modelos da Barra de Projetos usando o item de menu Arquivo> Painel de
Modelos> Desanexar ou clicando com o botão direito do mouse na guia do painel e
escolhendo Template Panel
> Desanexar no menu de atalho que aparece. Em seguida, reconecte o arquivo .tpo
depois de concluir as edições no arquivo do painel de modelos.
5 A janela Design da caixa de

diálogo
Uma parte importante de uma definição de módulo é a interface do usuário, que é a
parte visual que um modelador vê ao abrir a caixa de diálogo de um módulo ou
exibir os campos de um módulo na planilha de módulo.
A janela de design da caixa de diálogo é a interface da Arena para projetar a estrutura
da caixa de diálogo e o (s) layout (s) de formulário de caixa de diálogo de um
módulo. Nesta janela, um designer de módulo define os tamanhos das caixas de
diálogo, os dados que são apresentados e inseridos pelo usuário, os valores padrão e
permitidos e os controles da interface.
A primeira parte deste capítulo fornece uma visão geral da interface da janela de
design da caixa de diálogo. A segunda parte deste capítulo descreve os controles da
interface do usuário que são colocados na caixa de diálogo de um módulo. Isso inclui
objetos de formulário, operando e grupo de repetição, além de controles para entrada
do usuário e exibição de saída.
A terceira e quarta partes deste capítulo descrevem tópicos relacionados ao operando
e repetem objetos de grupo com mais detalhes.
A quinta e sexta partes deste capítulo descrevem o uso de teclas do acelerador e a
barra de ferramentas Design de Diálogo.

Visão geral da janela Design do diálogo

A janela de design da caixa de diálogo é aberta selecionando um módulo (no
modelo Definições do módulo da janela) e selecione a janela> Design da caixa de
diálogo
item de menu ou clicando no botão Dialog Design Window na barra de
ferramentas Template Development.
A janela de design da caixa de diálogo exibe os layouts de formulário da caixa de
diálogo para o módulo. Sua interface inclui uma seção Operand Explorer para
procurar todos os objetos de formulário, operando e grupo de repetição da caixa de
diálogo na definição do módulo; uma seção Caixa de ferramentas para adicionar
controles da interface do usuário aos formulários da caixa de diálogo; e uma grade
Propriedades de design para editar as propriedades de um ou mais objetos
selecionados.

77
UMARENA TEMPLATE DEVELOPER"S
GUIDE

O Operand Explorer
O Operand Explorer da janela de design da caixa de diálogo (localizado no canto
superior direito da janela) exibe a organização hierárquica do formulário, operando e
objetos de grupo de repetição da caixa de diálogo que definem a estrutura da caixa de
diálogo do módulo.

Figura 5.1 O Operand Explorer

O nó raiz da árvore do explorer é o formulário da caixa de diálogo principal do

módulo. Essa é a caixa de diálogo exibida pela primeira vez quando o modelador
clica duas vezes em uma instância do módulo em uma janela de modelo ou lógica.
Os objetos de formulário, operando e grupo de repetição da caixa de diálogo que
definem a estrutura da interface do módulo são exibidos na árvore do explorador de
acordo com os relacionamentos hierárquicos especificados. Os objetos são exibidos
usando o formato de sequência TabIndex: ObjectName [SwitchName]. A caixa de
diálogo ou o objeto de grupo de repetição destacado em negrito indica qual layout de
formulário da caixa de diálogo está aberto atualmente na janela.
Na árvore do explorador, você pode selecionar, excluir, cortar, copiar e colar
objetos. Os objetos também podem ser arrastados e soltos na árvore para alterar os
relacionamentos hierárquicos.
Clicar duas vezes em um objeto na árvore abre automaticamente o formulário da
caixa de diálogo associado ao objeto e o seleciona. Você também pode clicar no
botão Exibir caixa de diálogo Formulário ( ) para executar isso açao.
 As funções de forma de caixa de diálogo, operando e objetos de grupo de
repetição são descritas mais abaixo.
OBJETOS DO FORMULÁRIO DE DIÁLOGO
Uma definição de módulo contém um ou mais formulários de caixa de diálogo para exibir
opções e aceitar entradas dos modeladores nas instâncias do módulo.
Por padrão, cada módulo possui um formulário principal da caixa de diálogo. Essa
é a caixa de diálogo exibida pela primeira vez quando o modelador clica duas
vezes em uma instância do módulo em uma janela de modelo ou lógica.
Em alguns casos, pode haver muitas informações para colocar em uma única caixa de
diálogo. Você pode adicionar um novo objeto de formulário de caixa de diálogo
secundário para "aninhar" informações, colocando um controle DialogButton da Caixa
de Ferramentas no layout de um formulário de caixa de diálogo.
OBJETOS OPERACIONAIS
Um objeto operando é um objeto na definição de módulo que contém um único valor
e (se não estiver desativado ou oculto) pode ser editado com um controle de interface do
usuário pelo
usuário do modelo. Por exemplo, no módulo Parar do painel Transferência Avançada
do Arena, há um operando para o campo Nome do módulo e um operando para o
campo Nome do Transportador do módulo.
Você pode adicionar objetos operandos a uma definição de módulo, colocando
controles de interface do usuário, como um controle TextBox ou CheckBox da caixa
de ferramentas, no layout de um formulário da caixa de diálogo.
Operandos ocultos. Em alguns casos, não é desejável que um determinado
operando fique visível para o usuário do módulo. O operando existe apenas para
armazenar um dado para fins de lógica interna e, portanto, está sempre oculto do
usuário. O controle HiddenOperand da caixa de ferramentas é usado para adicionar
um objeto de operando oculto a uma definição de módulo.
REPETIR OBJETOS DO GRUPO
Um módulo pode fornecer a capacidade de definir uma lista de vários campos (ou
repetíveis). Por exemplo, o módulo Atribuir no painel Processo básico da Arena
permite que você
para atribuir valores a uma lista de variáveis, atributos e assim por diante. A caixa
de listagem Atribuições no módulo Atribuir é conhecida como um grupo de
repetição.
Você adiciona objetos de grupo de repetição a uma definição de módulo, colocando
um controle RepeatGroupDialog ou RepeatGroupTable da Caixa de Ferramentas no
layout de um formulário da caixa de diálogo. Use o controle RepeatGroupDialog se
os dados repetidos forem inseridos usando um formulário de caixa de diálogo
secundário. Use o controle RepeatGroupTable se os valores para um único campo
repetível devem ser inseridos em uma tabela.
 A caixa de ferramentas
A caixa de ferramentas da janela de design da caixa de diálogo (localizada no lado
esquerdo da janela) fornece uma interface para adicionar controles da interface do
usuário (por exemplo, caixas de texto, caixas de combinação ou botões da caixa de
diálogo) e gráficos estáticos (por exemplo, texto, linhas, ou caixas de grupo) para
um layout de formulário da caixa de diálogo.

Figura 5.2 A caixa de ferramentas

Para adicionar um controle da Caixa de Ferramentas, clique primeiro no controle

desejado na seção Caixa de Ferramentas. Em seguida, passe o ponteiro do mouse
sobre o local no formulário da caixa de diálogo onde o controle deve ser colocado.
O ponteiro mudará para uma cruz com o ícone do controle selecionado exibido na
parte superior e direita da cruz.
Os controles são colocados no formulário da caixa de diálogo por um dos três
métodos. Após a seleção do seu controle, você pode clicar no formulário para colocá-
lo onde desejar. Como alternativa, você pode clicar e arrastar para dimensionar o
controle conforme o coloca (o controle é colocado quando o botão é liberado). O
terceiro método de posicionamento é arrastar e soltar diretamente da caixa de
ferramentas para o formulário da caixa de diálogo.

80
Tabela 5.1 Resumo dos controles da caixa de ferramentas
Nome do Controle Descrição
Texto Usado para exibir uma sequência de texto simples em um
formulário da caixa de diálogo.
GroupBox Usado para desenhar uma caixa e, assim, fornecer um
agrupamento identificável para outros controles.
Linha Usado para desenhar segmentos de linha simples em um
formulário de caixa de diálogo.
Caixa de texto Usado para obter informações do usuário ou para exibir
texto.
Caixa combo Usado para exibir e editar dados em uma caixa de
combinação suspensa.
RadioButtonGroup Usado para apresentar um conjunto de duas ou mais opções
mutuamente exclusivas ao usuário. As opções são apresentadas
em uma matriz de botões.
CheckBox Usado para indicar se uma condição específica está ativada.
Permite ao usuário escolher entre dois valores como "Sim /
Não", "Verdadeiro / Falso" ou "Ativado / Desativado".
DialogButton Usado para fornecer um botão no qual o usuário clica para
exibir outro formulário da caixa de diálogo.
RepeatGroupDialog conjuntos de campos (ou repetíveis) em uma caixa de diálogo
secundária.
RepeatGroupTable Usado para permitir que um usuário insira valores para um
único campo repetível em uma tabela.
DateTimePicker Usado para fornecer uma interface através da qual trocar
informações de data e hora com um usuário.
DatePicker Usado para fornecer uma interface através da qual trocar
informações de data com um usuário.
TimePicker Usado para fornecer uma interface através da qual trocar
informações de horário com um usuário.
FilePicker Usado para fornecer uma interface para inserir um nome de
arquivo do sistema operacional.
HiddenOperand Usado para definir um objeto de operando que está oculto no
modelador (ou seja, não é exibido na caixa de diálogo do
módulo).
O formulário da caixa de diálogo
Um formulário de caixa de diálogo é um pedaço retangular da tela que apresenta
informações ao usuário e aceita informações do usuário. A interface do usuário de um
formulário de caixa de diálogo é definida colocando controles da caixa de ferramentas
da janela de design da caixa de diálogo na superfície do formulário.
Quando a janela de design da caixa de diálogo para uma definição de módulo é
aberta, por padrão, o formato da caixa de diálogo principal do módulo é exibido no
centro da janela. Essa é a caixa de diálogo exibida pela primeira vez se o modelador
clicar duas vezes em uma instância do módulo em uma janela de modelo.

Figura 5.3 Um formulário de diálogo na janela de design da caixa de diálogo

ABRIR UM FORMULÁRIO DE CAIXA DE DIÁLOGO

O design da caixa de diálogo de uma definição de módulo pode conter mais de um
formulário de caixa de diálogo. Por exemplo, além da caixa de diálogo principal, a
interface pode incluir uma ou mais caixas de diálogo secundárias acessadas usando
os controles DialogButton ou RepeatGroupDialog.
Para abrir o formulário da caixa de diálogo associado ou contendo um objeto
específico na definição do módulo, clique duas vezes nesse objeto no Operand
Explorer. Ou alternativamente,

82
você pode selecionar um objeto no Operand Explorer e usar o formulário Exibir>
caixa de diálogo
item de menu ou clique no botão Exibir caixa de diálogo Formulário )
Clicar duas vezes em um controle DialogButton ou RepeatGroupDialog em um
layout de formulário da caixa de diálogo também abrirá automaticamente o
formulário da caixa de diálogo associado a esse controle.
Redimensionando um formulário de caixa de diálogo
Para redimensionar um formulário de caixa de diálogo, primeiro clique em qualquer
lugar no formulário para selecioná-lo. Em seguida, clique e arraste uma das alças de
dimensionamento que aparecem na borda do formulário. As alças de
dimensionamento parecem pequenas caixas pretas e o ponteiro se transforma em uma
seta de duas pontas quando você aponta para a alça.
Você também pode inserir valores de dimensão específicos para um formulário da
caixa de diálogo, selecionando o formulário e editando as propriedades Altura e
Largura na grade Propriedades do design.
ARRANJANDO CONTROLES EM UM FORMULÁRIO DE CAIXA
DE DIÁLOGO
Os controles que foram colocados na superfície de um formulário da caixa de
diálogo podem ser selecionados, movidos e redimensionados.
Vários controles podem ser em camadas, alinhados, de tamanho igual ou
espaçados usando os comandos de menu disponíveis no menu Formatar.
Você também pode usar os comandos do menu Exibir> Grade, Exibir> Ajustar
à grade e Exibir> Ajustar a objetos para ativar / desativar os recursos de grade e
ajuste que ajudam a gerenciar locais de controle em um formulário.
CONTROLES DE BLOQUEIO EM UM FORMULÁRIO DE CAIXA
DE DIÁLOGO
Ao projetar a interface do usuário em um formulário da caixa de diálogo, você pode
bloquear os controles quando eles estiverem posicionados corretamente, para que você
não os mova ou redimensione inadvertidamente.
Use o item de menu Formatar> Bloquear controles para bloquear os controles de
um formulário de caixa de diálogo. Os controles de bloqueio evitam que eles sejam
arrastados para um novo tamanho ou local na superfície do formulário. No entanto,
você ainda pode alterar o tamanho ou o local dos controles por meio da grade
Propriedades do Design.

A grade Propriedades de design

A grade Propriedades de design da janela de design da caixa de diálogo (localizada
no canto inferior direito da janela) fornece uma interface para exibir ou editar
propriedades do (s) objeto (s) selecionado (s) no momento.
 Figura 5.4 A grade Propriedades do projeto

Na parte superior da grade Propriedades do design, há uma caixa de combinação.

Essa caixa de combinação exibe uma lista de todos os objetos contidos no
formulário da caixa de diálogo atualmente aberto na janela. A caixa de combinação
pode ser usada para alterar a seleção do objeto.
A parte inferior da seção Propriedades do design exibe uma descrição textual da
propriedade da grade selecionada no momento.

Usando os controles da caixa de ferramentas

Esta seção descreve com mais detalhes cada um dos controles da interface do
usuário disponíveis na caixa de ferramentas da janela de design da caixa de
diálogo.

Usando o controle de texto

Um controle de texto pode ser usado para exibir uma sequência de texto estática
simples em um formulário de caixa de diálogo.
O texto não pode ser editado pelo usuário.
Na grade Design Properties, a propriedade Text especifica a seqüência de caracteres
de texto exibida pelo controle. Se o texto digitado exceder a largura do controle, o
texto passará para a próxima linha e será cortado se exceder a altura do controle.
 Usando o controle GroupBox
Um controle GroupBox pode ser usado para desenhar uma caixa e, assim, fornecer
uma
agrupamento identificável para outros controles. Por exemplo, você pode usar controles de
caixa de grupo
subdividir funcionalmente um formulário e separar grupos de controles de botão de
opção.
Na grade Design Properties, a propriedade Text define a legenda da caixa de grupo.

Usando o controle de linha

Um controle de linha pode ser usado para desenhar segmentos de linha simples em um
formulário de caixa de diálogo.
Para desenhar uma linha em um formulário da caixa de diálogo, primeiro selecione o
controle Linha na Caixa de Ferramentas. Em seguida, clique no formulário em que
deseja que a linha comece. Arraste a cruz para onde deseja que a linha termine e
clique novamente.
Na grade Propriedades de design, as propriedades de design X1 e Y1 definem as
posições horizontal e vertical do ponto inicial do segmento de linha. As
propriedades de design X2 e Y2 definem as posições horizontal e vertical do ponto
final do segmento de linha.

Usando o controle TextBox

Um controle TextBox adiciona um objeto operando à definição do módulo. O controle
pode ser usado para obter entrada do usuário ou para exibir texto.
Um controle TextBox possui duas partes: um rótulo de prompt e uma caixa. Você
pode selecionar, mover e redimensionar a caixa e solicitar o rótulo separadamente no
formulário usando o mouse.
Na grade Design Properties, a propriedade Text define o rótulo do prompt da caixa
de texto. A propriedade Value especifica o valor padrão da string para a caixa de
texto. O tipo de dados que pode ser inserido como um valor é especificado pela
propriedade DataType.
Em geral, um controle TextBox é usado para texto editável, embora você possa
tornar uma caixa de texto somente leitura configurando a propriedade DisplayOnly
como True.
Na definição do módulo, os valores do objeto operando podem ser referenciados
(colocando o nome do objeto operando entre aspas, por exemplo, `Operand1`) na
propriedade Value de outro operando, em um objeto de animação na janela de
 visualização do usuário, em um campo de uma instância do módulo na janela
lógica ou em uma cadeia de definição de comutador.

Usando o controle ComboBox

Um controle ComboBox adiciona um objeto operando à definição do módulo. O controle
pode ser usado para exibir e editar dados em uma caixa de combinação suspensa. O
controle exibe
 uma caixa de edição com uma seta para baixo no lado direito da caixa. Clicar na seta
revela uma lista suspensa na qual o usuário pode selecionar um item.
Um controle ComboBox possui duas partes: um rótulo de prompt e uma caixa de
combinação. Você pode selecionar, mover e redimensionar o rótulo do prompt e a
caixa de combinação separadamente no formulário da caixa de diálogo usando o
mouse.
Na grade Design Properties, a propriedade Text define o rótulo do prompt da caixa
de combinação. O valor padrão da string para a caixa de combinação é especificado
na propriedade Value. O tipo de dados que pode ser inserido como um valor é
especificado pela propriedade DataType.
A lista de itens exibidos e disponíveis para seleção na lista suspensa da caixa de
combinação é definida pela propriedade List. Defina a propriedade
PickFromListOnly como True se desejar limitar a entrada de um usuário ao que está
na lista. Caso contrário, um usuário poderá digitar opções que não estão na lista no
campo de edição da caixa de combinação.
Na definição do módulo, os valores do objeto operando podem ser referenciados
(colocando o nome do objeto operando entre aspas, por exemplo, `Operand1`) na
propriedade Value de outro operando, em um objeto de animação na janela de
visualização do usuário, em um campo de uma instância do módulo na janela
lógica ou em uma cadeia de definição de comutador.

Usando o controle RadioButtonGroup

Um controle RadioButtonGroup adiciona um objeto operando à definição do módulo.
o controle pode ser usado para apresentar um conjunto de duas ou mais opções
mutuamente exclusivas ao
do utilizador. As opções são apresentadas em uma matriz de botões. Definir um
grupo de botões de opção informa ao usuário "Aqui está um conjunto de opções nas
quais você pode selecionar uma e apenas uma".
Na grade Propriedades de design, as opções de botão exibidas para o
RadioButtonGroup são definidas pela propriedade OptionList. A propriedade Text
define o rótulo do prompt para o grupo de botões. O valor da opção padrão para o
RadioButtonGroup é especificado na propriedade Value.
Defina a propriedade Boxed como True se desejar ter uma caixa de grupo
desenhada ao redor do rótulo do prompt e dos botões de opção. A organização da
coluna das opções do botão de opção também pode ser personalizada usando as
propriedades NumberOfColumns e ColumnWidth.
Na definição do módulo, os valores do objeto operando podem ser referenciados
(colocando o nome do objeto operando entre aspas, por exemplo, `Operand1`) na
propriedade Value de outro operando, em um objeto de animação na janela de
visualização do usuário, em um campo de uma instância do módulo na janela
lógica ou em uma cadeia de definição de comutador.
 Usando o controle CheckBox
Um controle CheckBox adiciona um objeto operando à definição do módulo. O controle
pode ser usado para indicar se uma condição específica está ativada. Use caixas de
seleção para dar
o usuário pode escolher entre dois valores como "Sim / Não", "Verdadeiro / Falso" ou
"Ativado / Desativado".
Na grade Design Properties, a propriedade Text define o rótulo do prompt da caixa de
seleção. O valor padrão para a caixa de seleção ("Sim" ou "Não") é especificado na
propriedade Valor.
Na definição do módulo, os valores do objeto operando podem ser referenciados
(colocando o nome do objeto operando entre aspas, por exemplo, `Operand1`) na
propriedade Value de outro operando, em um objeto de animação na janela de
visualização do usuário, em um campo de uma instância do módulo na janela
lógica ou em uma cadeia de definição de comutador.

Usando o controle DialogButton

Um controle DialogButton adiciona um formulário de caixa de diálogo secundário
à definição do módulo, fornecendo um botão no qual o usuário clica para exibir o
formulário.
Na grade Propriedades de design, use a propriedade Texto para especificar o texto
da legenda que aparece em um botão da caixa de diálogo.
Para abrir o formulário da caixa de diálogo secundário associado ao controle
DialogButton, clique duas vezes no objeto de formulário da caixa de diálogo do
controle no Operand Explorer. Ou você pode selecionar o objeto no Operand
Explorer e usar o item de menu Exibir> Formulário de Diálogo ou clicar no botão
Exibir Formulário de Diálogo ( )
Clicar duas vezes em um controle DialogButton em um layout de
formulário da caixa de diálogo também abre automaticamente o
formulário da caixa de diálogo associado a esse controle.

Usando o controle RepeatGroupDialog

Um controle RepeatGroupDialog adiciona um objeto de grupo de repetição à
definição do módulo. O controle permite que um usuário insira valores para vários
conjuntos de campos (ou repetíveis).
Cada conjunto de dados repetíveis é inserido usando um formulário de caixa de
diálogo secundário separado, acessado pela seleção dos botões Adicionar ou Editar
do grupo de repetição. Um conjunto de dados é excluído do grupo de repetição
usando o botão Excluir.
Na grade Design Properties, use a propriedade Text para especificar o rótulo do
prompt que aparece na parte superior do grupo de repetição.
Para abrir o formulário da caixa de diálogo secundário associado ao controle
RepeatGroupDialog, clique duas vezes no objeto de grupo de repetição do controle
no Operand Explorer. Ou,
 Como alternativa, você pode selecionar o objeto no Operand Explorer e usar o
item de menu Exibir> Formulário de caixa de diálogo ou clicar no botão Exibir
formulário de caixa de diálogo )
Clicar duas vezes em um controle RepeatGroupDialog em um layout de formulário
da caixa de diálogo também abrirá automaticamente o formulário da caixa de
diálogo associado a esse controle.

Usando o controle RepeatGroupTable

Um controle RepeatGroupTable adiciona um objeto de grupo de repetição à
definição do módulo. O controle permite que um usuário insira valores para um
único campo repetível em uma tabela.
Na grade Design Properties, use a propriedade Text para especificar o rótulo do
prompt que aparece na parte superior do grupo de repetição.
Um controle RepeatGroupTable pode ser usado apenas se houver exatamente um
campo de operando no grupo de repetição do controle cujo valor é editável pelos
usuários (referido como RepeatGroupTableOperand). O grupo de repetição pode
conter um número ilimitado de operandos ocultos.
Como exemplo, as tabelas de grupo de repetição são usadas no painel Elementos
para definir valores iniciais para os módulos de atributos e variáveis e os valores de
expressão no módulo Expressões.
Para exibir ou editar as propriedades dos objetos de operando contidos no grupo de
repetição do controle RepeatGroupTable, clique duas vezes no objeto de grupo de
repetição do controle no Operand Explorer. Ou, como alternativa, você pode
selecionar o objeto no Operand Explorer e usar o item de menu Exibir> Formulário
de Diálogo ou clicar no botão Exibir Formulário de Diálogo ( )
Clicar duas vezes no controle RepeatGroupTable em um layout de formulário
da caixa de diálogo também abre automaticamente o formulário da caixa de
diálogo associado a esse controle.

Usando o controle DateTimePicker

Um controle DateTimePicker adiciona um objeto operando à definição do módulo.
o O controle fornece uma interface simples e intuitiva através da qual é possível trocar
data e
informações de tempo com um usuário.
Um controle DateTimePicker possui duas partes: um rótulo de prompt e uma caixa
de edição. Você pode selecionar, mover e redimensionar o rótulo e a caixa do
prompt separadamente no formulário da caixa de diálogo usando o mouse.
A caixa de edição do controle possui uma seta para baixo à direita da caixa
(semelhante a um controle ComboBox). Clicar na seta exibe um calendário com o
valor da data atual circulado. O modelador pode alterar a parte da data inserida no
controle por
 selecionando um dia diferente no mês atual ou usando as teclas de seta do
calendário para especificar um mês diferente.
Para editar a parte da hora do controle, clique no texto da hora, minuto, segundo ou
AM / PM na caixa de edição. Em seguida, digite ou use as teclas de seta para alterar
um valor.
Na grade Design Properties, a propriedade Text define o rótulo do prompt para o
controle DateTimePicker. O valor padrão de data e hora para o controle é
especificado na propriedade Value. Se a propriedade Value não for especificada, o
valor padrão do controle será a data / hora atual.
Na definição do módulo, os valores do objeto operando podem ser referenciados
(colocando o nome do objeto operando entre aspas, por exemplo, `Operand1`) na
propriedade Value de outro operando, em um objeto de animação na janela de
visualização do usuário, em um campo de uma instância do módulo na janela
lógica ou em uma cadeia de definição de comutador.

Usando o controle DatePicker

Um controle DatePicker adiciona um objeto operando à definição do módulo. O
controle fornece uma interface simples e intuitiva através da qual é possível trocar
informações de datas
com um usuário.
Um controle DatePicker possui duas partes: um rótulo de prompt e uma caixa de
edição. Você pode selecionar, mover e redimensionar o rótulo e a caixa do prompt
separadamente no formulário da caixa de diálogo usando o mouse.
A caixa de edição do controle possui uma seta para baixo à direita da caixa
(semelhante a um controle ComboBox). Se a seta for clicada, um calendário
aparecerá com o valor da data atual circulado. O modelador pode alterar a data
selecionando um dia diferente no mês atual ou usando as teclas de seta do
calendário para especificar um mês diferente.
Na grade Design Properties, a propriedade Text define o rótulo do prompt do controle
DatePicker. O valor da data padrão para o controle é especificado na propriedade
Value. Se a propriedade Value não for especificada, o valor padrão do controle será a
data atual.
Na definição do módulo, os valores do objeto operando podem ser referenciados
(colocando o nome do objeto operando entre aspas, por exemplo, `Operand1`) na
propriedade Value de outro operando, em um objeto de animação na janela de
visualização do usuário, em um campo de uma instância do módulo na janela
lógica ou em uma cadeia de definição de comutador.
 Usando o controle TimePicker
Um controle TimePicker adiciona um objeto operando à definição do módulo. O controle
fornece uma interface simples e intuitiva através da qual é possível trocar informações
de tempo
com um usuário.
Um controle TimePicker possui duas partes: um rótulo de prompt e uma caixa de
edição. Você pode selecionar, mover e redimensionar o rótulo e a caixa do prompt
separadamente no formulário da caixa de diálogo usando o mouse.
A caixa de edição do controle TimePicker possui pequenas setas para cima e para
baixo à direita da caixa. Quando o valor atual da hora é selecionado (usando uma
pequena caixa de seleção à esquerda da hora), o valor da hora pode ser alterado
destacando a hora, minuto ou segundo e usando as setas para cima ou para baixo à
direita para aumentar ou diminuir A Hora.
Na grade Design Properties, a propriedade Text define o rótulo do prompt para o
controle TimePicker. O valor do tempo padrão para o controle é especificado na
propriedade Value. Se a propriedade Value não for especificada, o valor padrão do
controle será o horário atual.
Na definição do módulo, os valores do objeto operando podem ser referenciados
(colocando o nome do objeto operando entre aspas, por exemplo, `Operand1`) na
propriedade Value de outro operando, em um objeto de animação na janela de
visualização do usuário, em um campo de uma instância do módulo na janela
lógica ou em uma cadeia de definição de comutador.

Usando o controle FilePicker

Um controle FilePicker adiciona um objeto operando à definição do módulo. O
controle fornece uma interface simples para inserir um nome de arquivo do sistema
operacional.
O controle FilePicker exibe uma caixa de edição com um navegador (…) à
direita da caixa. Os usuários podem inserir um nome de arquivo válido ou clicar
no navegador para procurar o arquivo.
Um controle FilePicker possui duas partes: um rótulo de prompt e uma caixa de
edição. Você pode selecionar, mover e redimensionar o rótulo e a caixa do prompt
separadamente no formulário da caixa de diálogo usando o mouse.
Na grade Design Properties, a propriedade Text define o rótulo do prompt do
controle FilePicker. O nome do arquivo padrão para o controle é especificado na
propriedade Value.
Use a propriedade Filter para especificar os filtros de arquivo a serem exibidos na
caixa de diálogo Browse for File do controle (ou seja, as opções na lista suspensa

90
 Arquivos do tipo). Digite uma sequência de filtros usando o formato Descrição1 |
Padrão1, Descrição2 | Padrão2 e assim por diante.

90
 Um exemplo de uma sequência de filtros é: "Todos os arquivos | *. *, Arquivos de
texto | * .txt".
Você pode definir vários padrões de filtro para uma descrição de filtro,
separando os tipos de arquivo com ponto e vírgula. Por exemplo:
"Arquivos de imagem (*. BMP; *. JPG; *. GIF) | * .BMP; *. JPG; *. GIF, Todos
os arquivos (*. *) | *. *"
Na definição do módulo, os valores do objeto operando podem ser referenciados
(colocando o nome do objeto operando entre aspas, por exemplo, `Operand1`) na
propriedade Value de outro operando, em um objeto de animação na janela de
visualização do usuário, em um campo de uma instância do módulo na janela
lógica ou em uma cadeia de definição de comutador.

Usando o controle HiddenOperand

Um controle HiddenOperand adiciona um objeto operando à definição do módulo. O
controle é usado para definir um objeto de operando oculto do modelador (ou seja,
não exibido na caixa de diálogo do módulo).
Um operando oculto é normalmente usado para armazenar dados que são
necessários para a lógica do módulo, mas que não são necessários, desejáveis ou
permitidos para o modelador visualizar.
Na grade Design Properties, a propriedade Value de um operando oculto deve ser
especificada (exceto pontos de entrada e saída); caso contrário, não há como as
informações serem armazenadas no operando.
Na definição do módulo, os valores do objeto operando podem ser referenciados
(colocando o nome do objeto operando entre aspas, por exemplo, `Operand1`) na
propriedade Value de outro operando, em um objeto de animação na janela de
visualização do usuário, em um campo de uma instância do módulo na janela
lógica ou em uma cadeia de definição de comutador.

Usando operandos
Muitos dos controles de interface do usuário descritos na seção anterior, como os
controles TextBox, ComboBox e CheckBox, representam operandos no design da
caixa de diálogo do módulo. Um operando é um valor único importante para a
exibição do módulo ou para fins lógicos.
Esta seção descreve com mais detalhes algumas propriedades e problemas
relacionados ao operando.

Especificando a propriedade Nome

Todos os objetos operandos têm uma propriedade Name disponível na grade
Design Properties. Esta propriedade é uma cadeia de identificadores exclusiva para
o operando. A propriedade Text exibida no formulário da caixa de diálogo é
padronizada automaticamente como o Nome do operando.
O nome de um operando pode ser usado (colocando o nome entre aspas, por exemplo,
`Operand1`) para referenciar o valor do operando na propriedade Value de
outro operando, em um objeto de animação na janela de exibição do usuário,
em um campo de uma instância de módulo na janela lógica ou em uma cadeia
de definição de switch.
O comprimento máximo de um nome é 31 caracteres e deve ser especificado
usando caracteres alfanuméricos.

Especificando a propriedade LogicProperties

Todos os objetos de operando têm uma propriedade LogicProperties disponível na
grade Propriedades do Design. Essa propriedade fornece uma caixa de diálogo para
especificar características do operando relacionadas à sua finalidade na interface e
na lógica do módulo.

Figura 5.5 A caixa de diálogo Logic Properties para um objeto operando

Na caixa de diálogo Propriedades da lógica, o Tipo do operando é especificado

como Básico (o padrão), Elemento, Propriedade, Ponto de entrada ou Ponto de
saída.
OPERANDO BÁSICO
Um operando básico não serve a um propósito especial e é armazenado com cada
instância do módulo. Operandos básicos são freqüentemente usados para passar
valores para a janela lógica ou para a janela de visualização do usuário ou para
controlar a exibição de outros operandos, sendo usados nas definições de comutador.

92
OPERANDO DO ELEMENTO
Um operando de elemento define ou faz referência a um elemento SIMAN,
como uma estação ou recurso.
Se o Tipo for especificado como "Elemento", os seguintes campos serão exibidos
na caixa de diálogo Propriedades da lógica:
Tipo de elemento-O tipo de elemento SIMAN que o operando definirá ou fará
referência. Selecione o tipo desejado da lista. O valor do operando será usado
como o nome do elemento do tipo selecionado (por exemplo, um operando com o
valor "Operator" definirá ou fará referência a um elemento SIMAN com o nome
"Operator").
Sublist-A partição da sublista de elementos (por Tipo de elemento, como recurso)
dos quais o elemento deste operando deve ser um membro. Por exemplo, o tipo
de elemento Resources pode ter sublistas para Operadores e Máquinas.
Definir / Referência-Indica se o elemento criado por este operando deve ser definido
para o modelo de simulação ou se deve ser referenciado apenas. Se Referência
estiver selecionado, algum outro módulo deverá definir o elemento que é
referenciado por este módulo. Isso geralmente é usado quando informações de
propriedade incompletas são definidas em um módulo.
Para obter mais informações sobre o uso de elementos e suas propriedades, consultee
capítulo 10.

OPERAÇÃO DE PROPRIEDADE
Um operando pode ser usado para representar o valor da propriedade de um
elemento SIMAN, como o tipo de capacidade de um recurso.
Se o Tipo for especificado como "Propriedade", os seguintes campos serão
exibidos na caixa de diálogo Propriedades da Lógica:
Operando de elemento-Nome do operando que está definindo o elemento SIMAN
neste módulo ao qual esse operando de propriedade está associado.
Tipo de elemento-Tipo de elemento SIMAN definido / referenciado pelo
operando do elemento. Este campo não pode ser editado; é fornecido apenas
para informação.
Nome da propriedade-Nome da propriedade do elemento que este operando
define, selecionado em uma lista de propriedades válidas associadas ao Tipo de
Elemento.
Somente leitura-Esta opção está disponível apenas para os controles
HiddenOperand. Se ativado, o operando oculto lerá em seu valor o valor atual da
propriedade do elemento ao qual está associado. O valor da propriedade do
elemento NÃO será substituído pela entrada de valor padrão do operando. O valor
padrão definido para o operando oculto será
somente será gravado no valor da propriedade do elemento se essa propriedade
ainda não tiver sido definida (ou seja, o valor atual da propriedade é nulo).
Para obter mais informações sobre o uso de elementos e suas propriedades, consultee
capítulo 10.

PONTO DE ENTRADA OPERANDO

Um operando de ponto de entrada define um ponto de entrada do fluxo da entidade
no módulo. Quando você define um operando de ponto de entrada, um ponto de
entrada gráfico (formato de caixa) é colocado na visualização do usuário do módulo
para o operando, para que o ponto de saída de outro módulo possa ser conectado a
ele.
Na maioria dos casos, um módulo conterá apenas um operando de ponto de entrada.
Um designer de módulo deve ter cuidado ao usar vários pontos de entrada para
evitar erros de lógica. Pontos de entrada repetíveis não são permitidos. Se um
operando for definido como um ponto de entrada, a propriedade DataType do
operando será automaticamente restrita ao tipo de dados Label.
O Tipo de entrada especificado deve corresponder ao tipo de entrada do campo do
módulo que referencia o operando na janela lógica; por exemplo, se um rótulo de
entrada da fila estiver referenciando esse operando, o tipo de fila deverá ser
selecionado.
PONTO DE SAÍDA OPERANDO
Um operando do ponto de saída define uma saída para o fluxo da entidade para
fora do módulo. Quando você define um operando do ponto de saída, um ponto de
saída gráfico (forma de triângulo) é colocado na janela de visualização do usuário
para o operando, para que possa ser conectado ao ponto de entrada de outro
módulo.
Pode haver vários operandos de ponto de saída em uma definição de módulo. Por
exemplo, você pode projetar um módulo que execute um processo do tipo inspeção,
nesse caso, dois pontos de saída podem ser necessários, um para entidades que
passam na inspeção e outro para entidades que não passam na inspeção. Os pontos de
saída também podem ser repetidos, como pode ser visto no módulo Decidir do painel
Processo Básico. Um ponto de saída repetível (ou seja, o operando do ponto de saída
está associado a um objeto de grupo de repetição na definição do módulo) possui
uma representação gráfica diferente na visualização do usuário do que um único
ponto de saída, como pode ser visto na Figura 5.6.
Figura 5.6 Decida o módulo com pontos de saída repetíveis

O tipo de saída especificado deve corresponder ao tipo de saída do campo do módulo

que referencia o operando na janela lógica; por exemplo, se um rótulo de saída da fila
estiver referenciando esse operando, o tipo de fila deverá ser selecionado.
VALIDAÇÃO E REFERÊNCIA DO PONTO DE ENTRADA / SAÍDA
Uma conexão gráfica entre um operando de ponto de entrada e um operando de
ponto de saída pode ser feita apenas se a conexão for válida. A validação da conexão
é feita com base no Tipo de entrada e Tipo de saída dos operandos. O tipo mais
comum de entrada e saída usado é Padrão. Consulte o tópico do apêndice de
tabelas“Tipos de pontos de entrada ou saída” na página 275 para obter mais
informações sobre tipos de entrada e saída e validação de conexão. O apêndice de
tabelas também fornece informações sobre onde vários tipos de entrada e saída são
usados.
Quando é feita uma conexão gráfica entre os módulos, o Arena cria e armazena
automaticamente informações exclusivas de etiquetas de entrada e saída. Um valor de
rótulo de entrada, geralmente um número inteiro com um cifrão (por exemplo, 123 $),
é criado para o módulo ao qual a entidade deve ser enviada. O módulo do qual a
entidade é enviada recebe o mesmo valor do rótulo de saída.
Os operandos dos pontos de entrada e saída podem ter interruptores conectados a
eles. Se um ponto de entrada ou saída tiver um comutador e o operando estiver
desativado, o campo do operando não aparecerá na caixa de diálogo do módulo e o
símbolo gráfico não aparecerá na visualização do usuário do módulo.
Os operandos do ponto de entrada e saída também podem ser operandos ocultos (ou
seja, adicionados à definição do módulo usando os controles HiddenOperand). Nesse
caso, um campo correspondente ao operando não é visível para o modelador na caixa
de diálogo do módulo; no entanto, a representação gráfica do ponto de entrada ou
saída ainda aparece, oferecendo uma maneira de conectar-se ao módulo e sair dele.
Nota: Se um ponto de entrada ou saída for definido como oculto, não há como
referenciar esse operando se o módulo for usado hierarquicamente.
Em alguns dos exemplos deste guia, ocultamos os pontos de entrada e saída por
causa da caixa de diálogo exemplo e amostra. Esses módulos de exemplo não podem
ser usados como o primeiro ou o último módulo em uma janela lógica, pois não há
como referenciar o rótulo ou o próximo campo de rótulo.

MÓDULOS DE CRIAÇÃO AUTOMÁTICA

O recurso Módulo criado automaticamente permite que um designer de módulo
especifique que um novo módulo de dados separado será adicionado
automaticamente ao modelo usando esse operando. Quando usado, o valor do
operando é passado para o operando de nome do módulo de dados. A criação
automática ocorre apenas para valores não vazios do operando.
Por exemplo, se um módulo de dados chamado Recurso tiver um operando Nome
(especificado na caixa de diálogo Definição do Módulo) chamado Nome, e outro
módulo chamado Processo tiver um operando Nome do Recurso que crie
automaticamente o módulo de dados Recurso, o valor do módulo Process O Nome do
Recurso será passado para o operando Nome do módulo Recurso, desde que o Nome
do Recurso não esteja em branco.
Em geral, os operandos que usam o recurso Criação Automática devem ser definidos
como operandos do tipo Elemento. Isso garante que o módulo de dados tenha pelo
menos duas referências no modelo, pois os módulos de dados com apenas uma
referência são normalmente eliminados (ou seja, excluídos) do modelo (veja abaixo).
Além disso, eles devem ser configurados para usar a opção Referência, em oposição à
opção Definir, pois o próprio módulo de dados deve ser configurado para usar a
opção Definir.
Para usar o recurso Criação automática, clique no botão Configurações disponível
para criação automática do módulo na caixa de diálogo Propriedades da lógica e
especifique o Nome do modelo e o Nome do módulo do módulo que você deseja
criar a partir desse valor do operando. Você deve evitar nomes de caminho
codificados no campo Nome do modelo.
Nota: Você deve especificar o Nome do modelo, mesmo que o módulo a ser criado
automaticamente esteja no modelo atual. Além disso, lembre-se de alterar os
campos Nome do modelo e / ou Nome do módulo, se você renomear
posteriormente.

Limpar módulos de dados criados automaticamente. Os módulos de dados

criados automaticamente por outros módulos são excluídos automaticamente se as
seguintes condições se aplicarem: 1) o módulo que causou a criação automática é
excluído, 2) o módulo que causou a criação automática é editado com um valor em
branco para o operando que especificou a criação automática (ou o operando está
desativado) ou 3) o módulo criado automaticamente possui apenas uma referência no
modelo. Essa exclusão automática ocorre apenas se o módulo de dados não tiver sido
editado manualmente pelo usuário. Se alguma modificação ocorreu, o módulo
permanecerá.
Especificando a propriedade Value
Todos os objetos operandos têm uma propriedade Value disponível na grade Design
Properties. Esta propriedade especifica o valor padrão inicial do operando quando
uma instância do módulo é criada. Os valores padrão podem ser literais, podem
referenciar outros operandos ou podem ser uma combinação dos dois.
O tipo de dados aceitável para o valor de um operando que pode ser inserido por
um usuário é especificado usando a propriedade DataType. A propriedade do tipo
de dados é descrita em maisdetalhe, começando na página 101.
Não é possível ter um valor em branco para um operando que tenha um valor padrão
especificado no design da caixa de diálogo. Ao editar um módulo, se um modelador
apaga um operando com um valor padrão, o valor padrão reaparecerá quando o
usuário sair desse campo.
REFERENCIANDO O VALOR DE OUTRO OPERANDO
O valor armazenado em outro objeto de operando pode ser referenciado digitando o
Nome do operando entre caracteres de aspas posteriores (`). Quando um modelador
coloca e edita uma instância de um módulo contendo operandos referenciados,
todos os valores dos operandos são atualizados dinamicamente à medida que a
edição ocorre.
Por exemplo, suponha que um módulo contenha operandos Nome do Servidor e
Recurso do Servidor, e a propriedade Valor do operando do Recurso do Servidor
tenha sido especificada no design da caixa de diálogo como `Nome do
Servidor`_RES. Quaisquer alterações no nome do servidor do operando serão
refletidas no campo Recurso do servidor. Portanto, se o valor do Nome do servidor for
especificado como "Fred", o valor de Recurso do servidor será "Fred_RES".
Se um operando referenciado for desativado, seu valor será nulo.

COMBINANDO VALORES OPERACIONAIS DE REPETIÇÃO EM

UM VALOR ÚNICO
Ao projetar um módulo, você pode definir um objeto de grupo de repetição que
contenha um conjunto de operandos repetíveis e, em seguida, combinar esses valores
de operando repetidos em uma única cadeia de valor mesclada. O valor único será
retornado se você inserir a caixa de diálogo de grupo de repetição ou o nome do
objeto da tabela de grupo em caracteres de aspas posteriores (`) na propriedade Value
de um operando.
Este tópico é discutido em mais detalhes na seção "Usando grupos de
repetição" em página 103.
FUNÇÕES ESPECIAIS DE REFERÊNCIA
Está disponível um conjunto de funções especiais que fornecerá, no Valor padrão de
um operando, informações como o identificador exclusivo de uma instância do
módulo ou o número de conjuntos repetidos de dados armazenados em um grupo de
repetição.
Uma função especial é referenciada inserindo o nome da função entre
caracteres de quilate (^). A Tabela 5.2 resume as funções especiais disponíveis.
Algumas das funções disponíveis podem ser usadas para acessar informações
inseridas nas guias Parâmetros do projeto e Parâmetros de replicação da caixa de
diálogo Executar> Configuração de um modelo. Normalmente, isso pode ser feito
em um módulo projetado para substituir os padrões padrão dos parâmetros de
simulação e reorganizar as opções para o usuário final. Se um módulo que grava
valores diferentes para os elementos Projeto e Replicar for colocado em um modelo,
esses valores substituirão as configurações feitas na caixa de diálogo Executar>
Configuração.

Tabela 5.2 Funções especiais

Função
^ Module_ID () ^
^ Nome_do_Módulo () ^
^ Module_Number () ^
^ TIME_TO_BASE_TIME
(TimeVal ue, TimeUnits) ^
^ RATE_TO_BASE_RATE
(RateValu e, TimeUnits) ^
^ Line_Number () ^
^ Num_Lines (repetir nome do
grupo) ^
Descrição
Retorna uma cadeia de identificadores exclusiva
para o módulo no formato Nome da definição do
módulo [Número da instância]. Por exemplo,
"Criar 5."
Retorna o nome da definição do módulo. Por
exemplo, "Criar".
Retorna o número da instância do módulo no
modelo. Por exemplo, "5"
Converte um valor de tempo de unidades de
tempo em um valor de tempo de unidades de
tempo base (conforme especificado em
Executar> Configuração> Parâmetros de
Converte um valor de taxa de unidades de tempo
em um valor de taxa de unidades de tempo base
(conforme especificado em Executar>
Configuração> Parâmetros de replicação).
Retorna o índice nos conjuntos de dados repetidos
do grupo de repetição.
Retorna o número de conjuntos de dados
repetidos em um grupo de repetição.
^ Projeto_Título () ^ Fornece acesso ao título do projeto de simulação,
conforme obtido na página Parâmetros do Projeto.
Tabela 5.2 Funções especiais
Função
^ Nome do analista () ^
^ Use_Costing () ^
^ Use_Entities () ^
^ Use_Resources () ^
^ Use_Tanks () ^
^ Use_Queues () ^
^ Use_Transporters () ^
^ Use_Conveyors () ^
^ Use_Processes () ^
Descrição
Fornece acesso ao nome do analista do projeto,
conforme obtido na página Parâmetros do projeto.
Fornece acesso à caixa de seleção (Sim, Não)
para ativar e desativar cálculos de custo para o
modelo de simulação, conforme obtido na
página Parâmetros do projeto.
Fornece acesso à caixa de seleção (Sim, Não) para
ativar e desativar atributos e estatísticas da
entidade para o modelo de simulação, conforme
obtido na página Parâmetros do projeto.
Fornece acesso à caixa de seleção (Sim, Não)
para ativar e desativar estatísticas de recursos
para o modelo de simulação, conforme obtido
na página Parâmetros do projeto.
Fornece acesso à caixa de seleção (Sim, Não) para
ativar e desativar as estatísticas do tanque para o
modelo de simulação, conforme obtido na página
Parâmetros do projeto.
Fornece acesso à caixa de seleção (Sim, Não)
para ativar e desativar estatísticas da fila para
o modelo de simulação, conforme obtido na
página Parâmetros do projeto.
Fornece acesso à caixa de seleção (Sim, Não)
para ativar e desativar as estatísticas do
transportador para o modelo de simulação,
conforme obtido na página Parâmetros do
projeto.
Fornece acesso à caixa de seleção (Sim, Não)
para ativar e desativar as estatísticas do
transportador para o modelo de simulação,
conforme obtido na página Parâmetros do
projeto.
Fornece acesso à caixa de seleção (Sim, Não)
para ativar e desativar as estatísticas do
processo para o modelo de simulação,
conforme obtido na página Parâmetros do
projeto.
 Tabela 5.2 Funções especiais
Função
^ Estações_Uso () ^
^ Use_ActivityAreas () ^
^ Número_de_Replicações () ^
^ Replication_Length () ^
^ Initialize_System () ^
^ Initialize_Statistics () ^
^ StartDateTime () ^
^ Warm_up_Period () ^
^ Terminating_Condition () ^
^ Horas_Por Dia () ^
100
Descrição
Fornece acesso à caixa de seleção (Sim, Não)
para ativar e desativar as estatísticas da estação
para o modelo de simulação, conforme obtido
na página Parâmetros do projeto.
Fornece acesso à caixa de seleção (Sim, Não)
para ativar e desativar estatísticas da área de
atividade para o modelo de simulação,
conforme obtido na página Parâmetros do
projeto.
Fornece acesso ao número de replicações para um
projeto, conforme obtido na página Parâmetros de
Replicação.
Fornece acesso ao comprimento da execução da
simulação, conforme obtido na página Parâmetros
de replicação.
Fornece acesso à caixa de seleção (Sim, Não)
para inicializar o sistema entre replicações de
simulação, conforme obtido na página
Parâmetros de replicação.
Fornece acesso à caixa de seleção (Sim, Não)
para inicializar as estatísticas entre as
replicações de simulação, conforme obtido na
página Parâmetros de replicação.
Fornece acesso à data e hora de início da
simulação, conforme obtido na página
Parâmetros de replicação.
Fornece acesso ao período de tempo para o
período de aquecimento, conforme obtido na
página Parâmetros de replicação.
Fornece acesso à condição de finalização que
pode finalizar uma execução de simulação,
conforme obtido na página Parâmetros de
replicação.
Fornece acesso ao número de horas por dia
simulado, conforme obtido na página
Parâmetros de replicação.
Tabela 5.2 Funções especiais
Função
^ Base_Time_Units () ^
Descrição
Fornece acesso às unidades de tempo base usadas
para o relógio de simulação TNOW e a todas as
conversões de tempo, conforme obtido na página
Parâmetros de replicação.

Especificando a propriedade DataType

Todos os objetos de operando têm uma propriedade DataType disponível na grade
Propriedades do Design. Esta propriedade especifica o tipo de dados aceitável da
propriedade Value do operando.
Os tipos de dados definem o que um usuário tem permissão para inserir para um
valor de operando. Quando um usuário clica em OK na caixa de diálogo de um
módulo, o valor digitado para cada campo é verificado no tipo de dados do operando
para determinar se o valor digitado é válido. Se a entrada não for válida, um erro será
exibido e o ponteiro será movido para o campo do operando ofensivo.
Dependendo do tipo de controle, o tipo de dado de um operando pode ou não pode
ser alterado pelo designer do modelo. Por exemplo, o tipo de dados de um controle
CheckBox é estritamente "YesOrNo".
Os projetistas de módulos devem garantir que seus operandos não definam um tipo
de dados menos restritivo que os campos da janela lógica que fazem referência ao
operando. Por exemplo, se você possui um módulo na janela lógica que aceita
apenas valores reais para um campo específico, o operando mencionado nesse
campo deve ser um tipo de dados real ou mais restritivo (por exemplo, número
inteiro) .
Os tipos de dados disponíveis são descritos abaixo.

TIPOS DE DADOS PADRÃO

Alfanumérico- Permite qualquer sequência contendo caracteres alfabéticos e
numéricos, além de espaços incorporados.
AnyCharacter- Permite qualquer sequência de caracteres do teclado.
Expressão- Permite qualquer expressão numérica válida. Pode conter
combinações de letras, números e operadores aritméticos padrão. Um tipo de
dados de expressão pode conter expressões matemáticas e lógicas.
Inteiro- Permite qualquer valor inteiro não negativo válido. Se um tipo de dados
for especificado como Inteiro ou Real, você poderá especificar limites mínimos e
máximos para o operando.
Rótulo- Permite caracteres alfanuméricos, além dos caracteres especiais "@", "_,"
"%" e "#". Ele deve conter pelo menos um caractere ou letra especial. (Ele não deve
conter apenas caracteres numéricos com o único "e" ou "E", que pode ser
confundido com um número escrito em notação científica.)
Real- Permite qualquer valor real positivo ou negativo. Se um tipo de dados for
especificado como Inteiro ou Real, você poderá especificar limites mínimos e
máximos para o operando.
SymbolName- Permite caracteres alfanuméricos, além dos caracteres especiais "@",
"_," "%" e "#". Ele deve conter pelo menos um caractere ou letra especial. (Ele não
deve conter apenas caracteres numéricos com o único "e" ou "E", que pode ser
confundido com um número escrito em notação científica.)
Nota: Os nomes dos símbolos podem ter um comprimento ilimitado, mas apenas os
primeiros 255 caracteres de um nome são considerados na avaliação de uma
expressão.

Sim ou não- Permite que as cadeias de texto “Sim” ou “Não”.

TIPOS DE DADOS SIMAN

Além dos tipos de dados padrão, o Arena fornece alguns tipos de dados SIMAN. Eles
são mais restritivos que os tipos de dados padrão e geralmente são usados quando um
valor de operando pode ser obtido de um conjunto fixo de valores.
Por exemplo, se você estivesse construindo um módulo que definisse um
transportador e desejasse defini-lo como acumulativo ou não acumulável, você
poderia usar o tipo de dados ConvType, pois ele é definido como tendo dois
valores: Acumulativo e Não Acumulativo.
Para obter mais informações sobre os tipos de dados SIMAN disponíveis, consulte
“Tipos de dados” na página 264.

Especificando a propriedade SwitchName

Todos os objetos têm uma propriedade SwitchName disponível na grade Design
Properties. Esta propriedade especifica a opção conectada ao objeto. Quando a
condição do comutador é "False", o objeto será desativado ou oculto na caixa de
diálogo de acordo com a propriedade SwitchedOutAction.
Switches são definidos na janela Switch. Consulte "A janela do switch" napágina
175 para mais informações sobre switches.
Se um operando referenciado for desativado, seu valor será nulo.
Uma opção também pode ser anexada ou desanexada de um objeto usando os
comandos de menu Objeto> Alternar> Anexar ou Objeto> Alternar> Desanexar.

102
 Especificando a propriedade InUserView
Todos os objetos de operando têm uma propriedade InUserView disponível na grade
Propriedades do design. Essa propriedade permite que um valor de operando seja
exibido na visualização do usuário do módulo.
A propriedade InUserView é útil quando você deseja que o modelador veja
informações sobre os valores de operando de um módulo sem abrir a caixa de
diálogo do módulo.

Operandos ocultos
Em alguns casos, não é desejável que um determinado operando seja visível para o
usuário do módulo. O operando existe apenas para armazenar um dado para fins de
lógica interna e, portanto, é sempre "oculto" do usuário. O controle HiddenOperand
da caixa de ferramentas pode ser usado para adicionar um objeto oculto de operando
a uma definição de módulo.
Operandos de ponto de entrada e saída podem ser definidos usando o controle
HiddenOperand. Nesse caso, não haverá um campo para especificar uma etiqueta de
entrada ou saída na caixa de diálogo do módulo. No entanto, uma representação
gráfica do ponto de conexão ainda aparecerá na visualização do usuário do módulo,
permitindo que os usuários se conectem ou saiam do módulo.
Na grade Design Properties, a propriedade Value de um operando oculto deve ser
especificada (exceto pontos de entrada e saída); caso contrário, não há como as
informações serem armazenadas no operando.

Usando grupos de repetição

Alguns módulos permitem definir uma lista de vários campos (ou repetíveis).
Por exemplo, o módulo Atribuir no painel Processo Básico permite atribuir
valores a uma lista de variáveis, atributos e assim por diante. A caixa de listagem
Atribuições no módulo Atribuir é conhecida como um grupo de repetição.
Você adiciona objetos de grupo de repetição a uma definição de módulo, colocando
os controles RepeatGroupDialog ou RepeatGroupTable da Caixa de Ferramentas no
layout de um formulário da caixa de diálogo. Um controle RepeatGroupDialog é
usado se os dados repetidos devem ser inseridos usando um formulário de caixa de
diálogo secundário. Um controle RepeatGroupTable é usado se valores para um
único campo repetível devem ser inseridos em uma tabela.
Esta seção descreve com mais detalhes algumas propriedades e problemas repetidos
relacionados ao grupo.
Especificando a propriedade Nome
Todos os objetos de grupo de repetição têm uma propriedade Nome disponível
na grade Propriedades do Design. Esta propriedade é uma sequência
identificadora exclusiva para o grupo de repetição.
O comprimento máximo de um nome é 31 caracteres e deve ser especificado
usando caracteres alfanuméricos.
O nome de um grupo de repetição é referenciado ao usar a função Num_Lines ou ao
mesclar valores repetidos de operando em um único valor. Esses usos são discutidos
em “Acessando o número de tuplas e o número da tupla” empágina 107 e
“Combinando valores repetidos de operando em um único valor” em página 107.

Especificando a propriedade LogicProperties

Todos os objetos de grupo de repetição têm uma propriedade LogicProperties
disponível na grade Propriedades do Design. Essa propriedade fornece uma caixa
de diálogo para especificar características do grupo de repetição relacionadas à sua
finalidade na interface e na lógica do módulo.

Figura 5.7 A caixa de diálogo Logic Properties para um objeto de grupo de repetição

Na caixa de diálogo Propriedades da lógica, o Tipo do grupo de repetição é

especificado como Básico ou Propriedade.
GRUPO BÁSICO DE REPETIÇÃO
Um grupo de repetição básico não serve a um propósito especial e funciona
apenas como uma interface para o modelador acessar um conjunto de operandos
repetíveis.
GRUPO DE REPETIÇÃO DE PROPRIEDADE
Um grupo de repetição também pode ser usado para gravar valores na propriedade de
um elemento SIMAN. A propriedade deve ser uma propriedade repetível. Por
exemplo, um grupo de repetição pode ser usado para
grave valores na propriedade Members de um elemento SETS (como vários
membros podem ser definidos em um conjunto), mas não na propriedade Capacity
ou Schedule de um elemento RESOURCES.
Se o Tipo for especificado como "Propriedade", os seguintes campos serão
exibidos na caixa de diálogo Propriedades da Lógica:
Operando de elemento-Nome do operando que está definindo o elemento SIMAN
neste módulo ao qual este grupo de repetição de propriedade está associado.
Tipo de elemento-Tipo de elemento SIMAN definido / referenciado pelo
operando do elemento. Este campo não pode ser editado; é fornecido apenas
para informação.
Nome da propriedade-Nome da propriedade do elemento que este grupo de
repetição define, selecionado em uma lista de propriedades repetíveis válidas
associadas ao Tipo de Elemento.
Para mais informações sobre o uso de elementos e suas propriedades, consulte o
capítulo “Elementos” na página 183.

Repita a profundidade da definição do grupo e as regras

de referência
Ao usar grupos de repetição, é importante garantir que os campos e operandos
referenciados mantenham o nível correto de hierarquia. Se nenhum grupo de
repetição for usado na janela de design da caixa de diálogo ou em módulos na janela
lógica e os operandos não estiverem definidos como propriedades que devem estar
em um grupo de repetição, não haverá regras que precisem ser seguidas.
As restrições a seguir se aplicam ao referenciar um operando repetível (ou seja, um
operando contido em um grupo de repetição no design da caixa de diálogo) em um
campo de módulo na janela lógica:
1. Um operando repetível não pode ser referenciado em um campo de módulo na
janela lógica, se esse campo não for repetível. Por exemplo, não foi possível
fazer referência a um nome de operando repetível no campo Atraso no tempo de
um módulo Atraso avançado do processo na janela lógica.
2. Um operando repetível não pode ser referenciado em um campo de módulo na
janela lógica se o operando estiver em um nível mais profundo de repetibilidade
que o campo de módulo. Por exemplo, se você tivesse um objeto operando com
dois níveis de repetibilidade em profundidade no design da caixa de diálogo,
esse operando não poderia ser referenciado em um campo de módulo na janela
lógica que tivesse apenas um nível de repetibilidade em profundidade.
3. Os campos na mesma tupla de repetição (uma lista ordenada) em uma instância
do módulo podem fazer referência apenas aos objetos operandos conectados ao
mesmo grupo de repetição. Uma segunda tupla pode se referir a um operando
repetível diferente.
 Figura 5.8 Módulo hospitalar com dois grupos de repetição

Por exemplo, a Figura 5.8 mostra dois objetos de grupo de repetição (enfermeiros e
número necessário) com um único objeto de operando conectado a cada um. Não
seria permitido referenciar esses dois operandos da mesma tupla de grupo de
repetição em uma instância de módulo na janela lógica, como é mostrado na Figura
5.9.

Figura 5.9 Módulo hospitalar ilustrando o uso incorreto de referências de grupos repetidos
Acessando o número de tuplas e o número da tupla
Ao criar um módulo, você pode descobrir que precisará saber mais informações
sobre as entradas do grupo de repetição que o usuário final inseriu. Existem duas
funções especiais disponíveis para acessar essas informações.
^ Num_Lines (repetir nome do grupo) ^
Esta função retorna o número de tuplas que um modelador inseriu no grupo de
repetição de nome nome do grupo de repetição. Pode ser usado na propriedade
Value de um objeto operando fora do grupo de repetição ou em um campo de
módulo na janela lógica.
Num_Lines não pode ser usado diretamente em uma definição de opção. No entanto,
ele pode ser inserido como a propriedade Value padrão de um objeto operando. O
operando pode então ser referenciado em uma definição de chave.
^ Line_Number () ^
Esta função retorna o índice da tupla atual no grupo de repetição. Ele pode ser usado
na propriedade Value de um objeto de operando repetido que está contido
diretamente em um grupo de repetição no design da caixa de diálogo do módulo.
Um exemplo de onde a função Line_Number foi usada nos modelos padrão da
Arena está no módulo Atribuir do painel Processo Básico. No grupo de repetição de
atribuições, a função Line_Number foi usada para ajudar a fornecer nomes padrão
exclusivos para as entradas Nome do Atributo e Nome da Variável. Para esses
operandos, a propriedade Value padrão foi especificada como "Attribute ^
Line_Number () ^" e "Variable ^ Line_Number () ^". Portanto, nomes padrão como
“Atributo 1”, “Variável 2” e assim por diante, são automaticamente fornecidos ao
modelador pela caixa de diálogo do módulo.

Combinando valores repetidos de operando em um único

valor
Ao projetar um módulo, você pode definir um objeto de grupo de repetição que
contenha um conjunto de operandos repetíveis e, em seguida, combinar esses valores
de operando repetidos em uma única cadeia de valor mesclada.
O valor único será retornado se você inserir a caixa de diálogo de grupo de repetição
ou o nome do objeto de tabela de grupo de repetição em caracteres de aspas
posteriores (`) na propriedade Valor de um objeto de operando, em um objeto de
animação na janela de visualização do usuário, em um campo instância do módulo na
janela lógica ou em uma cadeia de definição de comutador.
Por exemplo, suponha que um objeto de caixa de diálogo de grupo de repetição
chamado “Chegadas de clientes” tenha sido adicionado a uma definição de módulo
“Clientes”. Usando a caixa de diálogo Repeat Group, um modelador especificará
CustomerType e CumulativeProbabiltity.
Figura 5.10 Design do diálogo do módulo Customers

Na lógica do módulo na janela lógica, suponha que o desenvolvedor do modelo

deseje que a string DISCRETE (0,0, CumulativeProb1, CustomerType1,
CumulativeProb2, CustomerType2,…) seja gravada no campo de uma instância do
módulo, em que CumulativeProb1 é a primeira probabilidade cumulativa valor
especificado no grupo de repetição, CustomerType1 é o primeiro tipo de cliente
especificado no grupo de repetição e assim por diante.
No campo do módulo na janela lógica, o desenvolvedor do modelo digita a string de
expressão: “DISCRETE (0,0` Chegadas de clientes`)”.
Para colocar separadores (isto é, vírgulas) entre os pares de probabilidade e valor
dos operandos e entre as entradas do grupo de repetição, o desenvolvedor do
modelo adiciona dois operandos ocultos denominados PairSeparator e
TupleSeparator. Ambos os operandos ocultos têm um caractere "," inserido em sua
propriedade Value.
A propriedade RepeatGroupIndex define um índice para o valor de um objeto em
relação a outros valores de objeto contidos no mesmo grupo de repetição e é
especificamente
 usado para determinar a ordem dos valores ao combinar operandos repetidos
de um grupo de repetição em uma única cadeia de valores mesclados.
Neste exemplo, os valores do operando devem ser mesclados na seguinte ordem:
 TupleSeparator
 Probabilidade cumulativa
 PairSeparator
 Tipo de Cliente
Portanto, o RepeatGroupIndex do operando TupleSeparator oculto é especificado
como 1, o RepeatGroupIndex do operando CumulativeProbability é especificado
como 2, o RepeatGroupIndex do operando PairSeparator oculto é especificado como
3 e o RepeatGroupIndex do operando CustomerType é especificado como 4.
Portanto, ao editar o módulo Customers, se o modelador inserir dois conjuntos de
entradas no grupo de repetição de Chegadas de clientes, como
CumulativeProbability = .3, CustomerType = 1) e (CumulativeProbability = 1.0,
CustomerType = 2), a sequência de expressões “DISCRETE (0,0` Chegadas de
clientes`) ”é escrito como“ DISCRETO (0,0, .3,1,1.0,2) ”.

Usando módulos repetíveis na janela lógica com

grupos de repetição
O recurso de módulo repetitivo permite criar um novo conjunto de lógica para cada
entrada ou tupla em um grupo de repetição. Um repetidor de módulo é colocado na
janela lógica e deve ser associado a um objeto de grupo de repetição na janela de
design da caixa de diálogo. Consulte a seção "Módulos repetíveis" empágina 139 no
capítulo "A janela lógica" para informações mais detalhadas.

Usando teclas aceleradoras

Um acelerador ou tecla de acesso permite que o usuário defina o foco em um controle
pressionando o
ALT tecla e digitando uma letra designada.
As teclas do acelerador podem ser definidas nos seguintes locais:
 Na propriedade Text de qualquer objeto. Na sequência de texto, digite um
caractere e comercial (&) imediatamente antes da letra que você deseja que seja
a tecla aceleradora (por exemplo, “Processo e Nome” para definir o “N” como a
tecla aceleradora).
  Na propriedade OptionList de um controle RadioButtonGroup. Na parte do alias
de um valor de opção, digite um caractere e comercial (&) imediatamente antes
da letra que você deseja que seja a tecla aceleradora (por exemplo, “Opção 1 |
Opção & 1”).
É uma boa prática de design identificar chaves aceleradoras exclusivas em qualquer
caixa de diálogo única.

Barra de ferramentas Design da caixa de

diálogo
Enquanto trabalhava na janela de design da caixa de diálogo, pode ser útil exibir e usar
os controles associados à barra de ferramentas Design da caixa de diálogo. A barra
de ferramentas contém controles para formatar e exibir objetos colocados na janela.
Os controles também estão disponíveis nos menus Exibir, Formato e Objeto.
Para ocultar ou exibir a barra de ferramentas Design da caixa de diálogo, escolha
Exibir> Barras de ferramentas> Design da caixa de diálogo ou clique com o
botão direito do mouse em qualquer barra de ferramentas visível e escolha
Design da caixa de diálogo na lista.

110
6 A janela lógica
Lógica de simulação e design de módulos
O coração de um módulo é sua lógica de simulação. As entidades que chegam a
uma instância de módulo durante uma execução de simulação podem passar por
uma atividade simples, como um atraso de tempo ou uma série de atividades
complexas, como atracar em um estaleiro ou concluir uma operação cirúrgica
completa. O designer de um módulo tem controle total sobre o escopo da lógica do
módulo. É esse aspecto do design do módulo que é mais desafiador e
frequentemente mais interessante.
Por exemplo, se suas atividades de modelagem estiverem na área de manufatura de
alimentos a granel, você poderá criar um módulo que represente a chegada de
matérias-primas de várias fontes à sua instalação de manufatura. Para capturar os
aspectos pertinentes dessa atividade, pode ser necessário representar os caminhões
que entregam as matérias-primas, os compartimentos dos caminhões na área de
recebimento, as empilhadeiras que descarregam paletes dos caminhões e o pessoal
que desembrulha os materiais paletizados e os transfere para uma área de
armazenamento. Uma abordagem pode ser a construção de um módulo de
recebimento de matéria-prima que capture todas essas atividades, desde caminhões
que chegam às instalações até o armazenamento da matéria-prima para uso na
fabricação. Outra abordagem pode separar a operação de recebimento em três
módulos individuais: Chegadas de Caminhões, Descarga de Caminhões e Transferir
para Armazenamento.
A decomposição dessa atividade poderia naturalmente ser representada usando a
hierarquia da Arena. Independentemente do design selecionado para os módulos,
será necessário modelar cada uma das atividades de nível mais baixo (por exemplo,
entrada de caminhões na instalação, seleção de um compartimento de caminhões,
atracação no compartimento de caminhões). Você pode primeiro criar módulos para
representar cada uma dessas atividades, combiná-los nas atividades de nível médio
(por exemplo, chegadas de caminhões) e, finalmente, criar o módulo Recebimento
de matéria-prima a partir dos módulos de nível médio.
Ao usar essa abordagem, um modelador que use esse modelo terá a opção de usar o
módulo de alto nível (recebimento de matéria-prima) ou representar o processo de
recebimento usando os módulos de nível médio ou inferior. O trabalho adicional
envolvido na criação de módulos nos três níveis de decomposição refere-se
principalmente à seleção de operandos do módulo - para criar um módulo de entrada
de caminhão, você deve decidir quais opções serão alteráveis (por exemplo, tempo
entre chegadas de caminhões, tipo de caminhão) por usuários do módulo.
 6 • TELE euOGIC
WINDOW

A janela lógica
A janela lógica de um módulo define um submodelo; isto é, a lógica de modelagem
e os dados que serão gerados quando uma instância do módulo for colocada na
janela. Assim como a janela do modelo é usada para definir a representação lógica
de um modelo, a janela lógica define a representação lógica de um módulo. Você
pode pensar na janela lógica como uma janela modelo em quase todos os aspectos;
discutiremos as diferenças entre essas duas janelas na próxima seção deste capítulo.
Para abrir a janela lógica de uma definição de módulo, selecione Janela> Lógica na
barra de menus principal ou clique no botão Janela Lógica na barra de ferramentas
Desenvolvimento de Modelo. Uma janela lógica de amostra é mostrada na Figura
6.1.

Figura 6.1 Janela de lógica de amostra para um módulo Chegando clientes

Você interage com uma janela lógica da mesma maneira que trabalha com uma janela
do modelo Arena. Para definir a lógica do módulo, você anexa painéis de modelo à
Barra de Projetos, seleciona módulos, coloca instâncias deles na janela lógica, conecta
as instâncias do módulo e fornece valores aos seus operandos.
Ao ler este capítulo, lembre-se de que as instâncias do módulo podem ser colocadas
em modelos de simulação (ou seja, em janelas de modelo que serão armazenadas
como arquivos Arena .doe) ou em definições de módulo (ou seja, em janelas lógicas
de módulos que serão ser armazenado em
.tplarquivos). Para simplificar, na maioria dos lugares nos referimos aos
modeladores que colocam instâncias de módulos em modelos de simulação. No
entanto, lembre-se de que instâncias também podem ser colocadas em janelas
lógicas.

112
 As seções restantes deste capítulo discutem o uso de janelas lógicas para definir a
lógica de simulação associada a uma definição de módulo. Não apresentamos uma
discussão da interface geral para a construção de modelos de Arena. Supomos que
você esteja familiarizado com as etapas envolvidas na construção de modelos usando
os painéis de modelo do Arena.
A próxima seção deste capítulo destaca as principais diferenças entre janelas de
modelo, usadas para criar e executar modelos de simulação, e janelas lógicas de
definições de módulo. A seguir, apresentamos três seções que descrevem os
principais recursos das janelas lógicas relacionadas especificamente à definição de
módulos: referenciar operandos de módulo, conectar módulos na janela lógica e
alternar instâncias de módulo na janela lógica. As próximas duas seções do capítulo
discutem tópicos de particular interesse no design da lógica do módulo: definindo o
rastreio do módulo e usando os módulos do modelo de utilitário Arena
(utlarena.tpo). Encerramos este capítulo resumindo regras e apresentando diretrizes
relacionadas à definição da lógica do módulo.

Diferenças entre janelas lógicas e

modelo
Executando modelos de simulação (janela de modelo)
O processo geral de definir uma janela lógica é idêntico ao da construção de um
modelo de Arena. Como as janelas lógicas são semelhantes às janelas de modelo (ou
seja, ambas contêm instâncias de módulos), a maioria das informações de edição para
trabalhar em janelas de modelo também se aplica à criação e modificação de janelas
lógicas. Consulte o Guia do usuário do Arena para obter informações sobre como
anexar painéis de modelos, colocar e editar módulos, conectar módulos e assim por
diante.
Um recurso que as janelas de modelo possuem que não é oferecido para janelas
lógicas é a capacidade de realizar uma execução de simulação. Se você abrir a
janela lógica de um módulo, notará que a barra de ferramentas Executar não está
visível.
Para usar a lógica incorporada em uma definição de módulo para executar uma
execução de simulação, você deve primeiro colocar uma instância do módulo em um
modelo e, em seguida, executar a lógica simulando o modelo que contém a instância
do módulo. Ou você pode testar a lógica do módulo definindo a lógica em uma janela
de modelo e depois usando a área de transferência para copiar a lógica verificada na
janela de lógica do módulo. Dessa maneira, você tem a vantagem de usar o Run
Controller da Arena para interagir com a lógica do módulo.
Operandos de referência (janela lógica)
As janelas lógicas possuem vários recursos adicionais que não são fornecidos pelas
janelas de modelo. Primeiro, uma instância do módulo em uma janela lógica pode
obter valores para seus operandos fazendo referência a operandos definidos na
janela de design da caixa de diálogo da definição do módulo.
Por exemplo, um módulo que representa a atividade de descarga de um caminhão
pode incluir um operando que define o tempo para descarregar um palete. Esse
operando pode ser referenciado por uma instância do módulo Delay (no painel
Advanced Process da Arena ou no painel Blocks) na janela lógica para gerar o
atraso de tempo apropriado na lógica do modelo. Cada vez que uma instância desse
módulo de descarregamento de caminhão é colocada em um modelo (ou na janela
lógica de outro módulo), um novo valor pode ser atribuído ao operando do tempo de
descarregamento, gerando lógica de simulação personalizada.“Referenciando Dados
do Módulo” em página 116 descreve este tópico.

Alternando instâncias do módulo (janela lógica)

Ao trabalhar em uma janela lógica, você pode anexar comutadores às instâncias do
módulo. Um comutador é apenas uma construção que possui um valor verdadeiro ou
falso, em que o valor do comutador é determinado pelos valores dos operandos do
módulo e de outros comutadores do módulo, ou ambos. (Consulte “A janela do
switch” na página 175 para obter uma descrição de como definir opções.)
Na janela lógica, os comutadores são usados para controlar alternativas para a lógica
do modelo a ser usada quando o modelador altera os valores do operando. Por
exemplo, em um módulo que representa uma máquina de estampagem de metal, você
pode oferecer a opção de contar o número de vezes que os atolamentos ocorrem. Se o
modelador indicar que a contagem deve ser realizada, um módulo Count do painel
Blocks seria ativado no local apropriado na lógica do módulo. No entanto, se não for
necessário contar, o módulo Count não deve ser incluído nessa instância específica
do módulo da máquina de estampagem (ou seja, está desativado). Isso é descrito com
mais detalhes em"Switches na lógica instâncias do módulo de janela ”na página 124.

Definindo lógica repetível

As janelas lógicas do modelo têm um objeto especial chamado Repetidor de módulo
que pode ser colocado na janela lógica e usado para definir módulos que devem ser
repetidos para cada item em um objeto de grupo de repetição da janela de design da
caixa de diálogo. O repetidor do módulo é colocado selecionando-o no menu
Módulo. Para obter mais informações sobre o uso desse recurso, consultee “Módulos
repetíveis” na página 139.
Conexões do módulo na janela lógica
A janela lógica permite dois métodos adicionais para conectar módulos que não são
permitidos nas janelas do modelo. Primeiro, um ponto de saída na janela lógica pode
ser conectado a vários pontos de entrada, o que não é permitido na janela do modelo.
Isso é permitido na janela lógica para permitir que os comutadores selecionem dentre
os caminhos lógicos alternativos em uma instância do módulo.
Segundo, a conexão de um ponto de saída repetido pode ser duplicada quando o
módulo é usado em um modelo. Isso permite que todas as condições repetidas
definidas pelo modelador enviem entidades para a mesma lógica automaticamente.
Esses dois tópicos de conexão são discutidos e ilustrados em "Conexões do
módulo" na página 148.

Anexando painéis de modelo enquanto trabalhava

em uma janela lógica
Enquanto estiver na janela lógica de uma definição de módulo em um determinado
modelo (ou seja, arquivo .tpl), não é possível colocar nenhum módulo definido no
modelo atual. Por exemplo, se você estiver trabalhando em um arquivo de painel de
modelo chamado foodline.tpl, não poderá colocar nenhum módulo de foodline.tpo
na janela lógica de qualquer outro módulo definido em foodline.tpo.
Relacionado a isso, você não pode anexar um modelo a si próprio indiretamente,
anexando um arquivo .tpo que possui o modelo que você está editando anexado à
barra do projeto. Por exemplo, você pode ter um modelo chamado truckops.tpl
representando as operações de chegada de caminhões descritas anteriormente. Se
esse modelo contiver instâncias de módulo do foodline.tpo em qualquer uma das
janelas lógicas de definição de módulo, não será permitido o uso de módulos do
truckops.tpo ao definir os módulos no modelo foodline.tpl.
Se você possui um conjunto de módulos que formam uma hierarquia (como os três
níveis de módulos descritos anteriormente relacionados à operação de recebimento
de matérias-primas), eles devem ser agrupados em arquivos de modelo separados,
pois um modelo específico não pode conter instâncias de módulos que são definidos
no mesmo modelo.

Exibição de objetos de animação (janela lógica)

Quando você coloca um módulo em uma janela lógica, uma instância completa é
formada, exatamente como ocorreria se você colocasse o módulo em uma janela de
modelo. No entanto, como uma janela lógica não pode ser simulada diretamente,
não há necessidade de animação na janela.
 Portanto, a janela lógica do Arena, por padrão, não exibe os objetos de animação que
fazem parte de uma instância do módulo.
Se você colocar uma instância de módulo na janela lógica que contém objetos de
animação em sua visualização do usuário, esses objetos de animação são colocados
na janela lógica; eles não são exibidos por padrão. Se você deseja visualizar os
objetos de animação, pode usar o botão Exibir
> Camadas item de menu para ativar a exibição dos vários tipos de objetos de
animação (por exemplo, níveis e recursos). Na janela lógica, mantemos os objetos
de animação que fazem parte das visualizações do usuário da instância do módulo,
para que um módulo transferido entre uma janela de modelo e uma janela lógica
(usando a área de transferência) permaneça completo.

Campos e operandos
Neste capítulo, discutimos instâncias de módulos em dois contextos: o
posicionamento de instâncias de módulos em uma janela lógica (ou seja, para criar a
lógica para uma definição de módulo) e o uso do módulo que definimos (ou seja, a
criação de uma instância em um modelo ou na janela lógica de outro módulo).
Também temos dois contextos para o termo operando: o item que é apresentado na
caixa de diálogo de uma instância do módulo na janela lógica e o operando definido
por um objeto colocado na janela de design da caixa de diálogo de uma definição de
módulo.
Para remover a confusão neste capítulo sobre o termo operando, optamos por usar
um termo diferente, campo, para o primeiro contexto. Portanto, neste capítulo, nos
referimos aos itens que aparecem na caixa de diálogo de uma instância do módulo
como campos. Retemos o termo operando em seu contexto como o objeto que faz
parte de uma definição de módulo.

Referenciando Dados do Módulo

Operandos de referência
A janela lógica define a lógica que ocorrerá (controlando a criação, fluxo e descarte
de entidades) quando uma execução de simulação for executada por um modelo que
contém uma instância do módulo. Essa lógica pode ser muito simples ou altamente
complexa. Quando um módulo é colocado, o número e os tipos de opções fornecidas
ao usuário são definidos pelas caixas de diálogo que contêm os operandos do
módulo.
O vínculo entre a janela de design da caixa de diálogo e a janela lógica é estabelecido
dentro da janela lógica. Em cada instância do módulo na janela lógica, os valores dos
operandos das caixas de diálogo do módulo que está sendo projetado podem ser
usados no lugar de valores específicos. Para estabelecer esse link, digite o nome do
operando que você deseja
para usar e colocar o nome entre caracteres de aspas posteriores (`). Nós nos referimos
a isso como
referenciamento um operando.
Nota: Os nomes dos operandos são não diferencia maiúsculas de minúsculas.
Espaços incorporados são permitidos.

As referências de operando também são permitidas na propriedade Value de uma

definição de operando e para definir determinados dados para objetos de animação.
Os capítulos “A Janela de Design de Diálogo” e “A Janela de Visualização do
Usuário” descrevem os locais em que as referências de operando podem ocorrer
para valores padrão de operando e objetos de animação, respectivamente.
Uma referência de operando determina que, quando uma instância do módulo é
criada, o valor real do campo que contém a referência deve ser obtido a partir da
entrada do modelador na caixa de diálogo do módulo. Sua seleção dos operandos de
um módulo e as referências a esses operandos na janela lógica determinam a
flexibilidade fornecida a um modelador para personalizar os dados e o
comportamento do módulo, pois ele é usado para representar diferentes
circunstâncias.
Para ilustrar uma referência simples de módulo, considere um módulo Entrada de
Pedido que contenha uma instância de um módulo Criar (no painel SIMAN Blocks).
Neste módulo, você pode solicitar ao modelador que defina o tamanho do lote do
pedido e o tempo de chegada dos pedidos ao sistema. Para fazer isso, você pode
definir dois operandos na janela de design da caixa de diálogo: Tempo entre pedidos e
Tamanho do pedido. Na instância do módulo Create que você coloca na janela lógica
da definição do módulo, você referencia o operando Tempo Entre Pedidos para obter
o intervalo para o módulo Create e o operando Tamanho do Pedido para obter o
tamanho do lote, conforme mostrado na Figura 6.2.
Sempre que um modelador coloca uma instância do módulo Entrada de pedidos,
novos valores podem ser fornecidos para os operandos Tempo entre pedidos e
Tamanho do pedido. Por exemplo, uma instância do módulo Entrada de Pedidos pode
especificar um valor do operando Tempo Entre Pedidos de UNIF (5,10) e um
Tamanho de Pedido de 10. Na lógica subjacente, esses valores passariam para o
módulo Criar para que o campo Intervalo no módulo Criar teria um valor de UNIF
(5,10) e o campo Tamanho do lote teria um valor de 10.
Nota: Se um módulo contendo referências de operando for colado em um modelo
(.dae), os campos que contêm referências são restaurados para seus valores padrão.
Figura 6.2 Exemplo de referências de operando

CONCATENANDO TEXTO A OPERANDO REFERÊNCIAS

Ao referenciar um operando, você também pode digitar o texto antes ou depois da
referência. Por exemplo, você pode ter outro módulo no seu modelo chamado
Verificação de Pedido, em que ocorre um atraso para verificar os pedidos. Neste
módulo, convém projetar a interface para que um modelador insira a porcentagem de
pedidos incompletos (ou seja, um valor no intervalo de 0 a 100) em um operando
chamado Porcentagem Incompleta. Se esse valor for usado na condição de um
módulo Branch (no painel Blocks), que requer um valor de probabilidade (ou seja, no
intervalo de 0,0 a 1,0), você precisará dividir a entrada
do modelador em 100. Para fazer isso, você pode combinar a referência do
operando (`Porcentagem incompleta`) com o texto (/ 100), como mostra a Figura
6.3.

Figura 6.3 Concatenando referências e texto de operando

Nesse caso, o valor digitado pelo modelador para a porcentagem de pedidos

incompletos terá o texto / 100 anexado antes que as informações sejam passadas para
a lógica que define o módulo Filial. Por exemplo, se um modelador digitasse um
valor 14 para o campo de porcentagem em uma instância do módulo Verificação de
Pedidos, as informações reais fornecidas ao módulo Filial seriam 14/100 (através da
janela lógica da definição do módulo Verificação de Pedidos).

COMBINANDO MÚLTIPLAS REFERÊNCIAS DE OPERANDO EM

UM ÚNICO CAMPO
Vários operandos podem ser referenciados no mesmo campo de uma instância do
módulo na janela lógica. Nesse caso, os valores dos operandos são concatenados
para formar o valor completo da instância do módulo da janela lógica. Além disso,
o texto pode ser intercalado com referências de operando (conforme descrito
anteriormente).
Por exemplo, no módulo original, Entrada de pedidos, você pode decidir usar uma
distribuição uniforme para o tempo de chegada dos pedidos e pedir ao modelador o
mínimo
 tempo e o tempo máximo. Nesse caso, o operando Tempo entre pedidos seria
removido do módulo. Em seu lugar, você pode definir dois operandos para o seu
módulo: Mín e Máx. Para referenciar esses operandos, você alteraria a referência do
operando no módulo Create (campo Interval) para UNIF (`Min`,` Max`), como
mostra a Figura 6.4.

Figura 6.4 Referenciando múltiplos operandos

Em uma instância deste módulo de entrada de pedidos, as entradas do modelador

para o tempo mínimo e o tempo máximo substituem as referências do operando
(`Min` e` Max`, respectivamente) no módulo Create.
Outro caso em que é útil referenciar vários operandos em um único campo de um
módulo é quando um conjunto de operandos é fornecido ao usuário, mas esses
operandos são controlados por comutadores, de modo que apenas um operando será
comutado para um determinado conjunto de entradas do usuário. (Veja o capítulo“A
janela Design de diálogo”para obter uma descrição da conexão de comutadores aos
operandos. Vejo"A janela do switch" para uma discussão sobre opções e suas
definições.) Para definir o campo da janela lógica para esse tipo de referência, digite
cada nome de operando entre aspas, uma após a outra.

120
No módulo de exemplo Verificação de Pedido, talvez você queira projetar o
módulo para oferecer ao modelador a opção de especificar o horário para verificar
o pedido como o nome de um atributo que armazena o horário ou como um horário
específico. Esta informação será usada em um módulo Delay (no painel Blocks). A
caixa de diálogo do módulo pode conter uma seleção para o tempo de verificação
com as opções de tempo ou atributo. Se o modelador selecionar Time, um
operando chamado Time será exibido; se o modelador selecionar Atributo, um
Atributo será exibido.
A Figura 6.5 mostra a caixa de diálogo para uma instância do módulo Verificação de
pedidos com o tempo de verificação selecionado como tempo. A Figura 6.6 mostra a
mesma caixa de diálogo com o atributo selecionado.

Figura 6.5 Exemplo do módulo Verificação de pedidos, seleção de horário

Figura 6.6 Exemplo do módulo Verificação de pedido, seleção de atributo

Na Figura 6.5, o operando Time é exibido para que o modelador possa definir o
tempo como um valor (por exemplo, 2.5). A caixa de diálogo na Figura 6.6 permite
que o modelador defina o tempo para verificar um pedido, selecionando (em uma
lista suspensa de atributos) um atributo que armazena o valor.
Na janela lógica da definição do módulo Verificação do Pedido, o campo Tempo
do Processo do módulo Delay seria definido como `Time``Attribute` (sem espaços
em branco). O operando ligado forneceria seu valor ao módulo Delay; o operando
comutado não teria valor (ou seja, em branco). A caixa de diálogo para a instância
do módulo Delay na janela lógica é mostrada na Figura 6.7.

Figura 6.7 Exemplo de combinação de referências de operando

MÚLTIPLAS REFERÊNCIAS A UM OPERANDO

Ao definir um módulo, é possível referenciar o mesmo operando quantas vezes for
apropriado. Como mencionamos anteriormente, as referências de operando podem
ser feitas em três locais em uma definição de módulo: na propriedade Value de um
objeto operando na janela de design da caixa de diálogo, na janela lógica (conforme
descrito neste capítulo) e nos objetos de animação em a visão do usuário do módulo.
O mesmo operando pode ser referenciado nas três janelas e / ou em vários objetos em
uma janela.
Por exemplo, se um recurso for necessário para executar o processo de verificação
do pedido, um operando Clerk Name será adicionado ao módulo. Isso forneceria o
nome do recurso em um módulo Process. (Discutiremos a adição do nome do
funcionário ao módulo Process em“Fazendo referência a operandos não repetitivos
de um grupo de repetição” em página 129.) Se uma contagem for coletada no
módulo Verificação de pedidos para registrar o número de pedidos incompletos que
cada funcionário detecta, o operando Nome do funcionário no

122
O módulo pode ser referenciado em muitos lugares. O valor padrão de outro
operando do módulo que define o nome do contador pode fazer referência ao
Nome do Funcionário para formar a base do nome do contador (por exemplo,
`Nome do Funcionário`_Cnt). A instância do módulo Process na janela lógica
contém a referência ao Nome do Funcionário para definir o recurso. E na visão do
usuário, um objeto de animação de recurso poderia fazer referência ao Nome do
Funcionário para o identificador de recurso.

Acesso especial para caixas de seleção, grupos de

botões de opção e caixas de combinação
Embora todas as referências aos operandos do módulo sejam feitas colocando o
nome do operando entre aspas, é necessário um mecanismo especial para criar essas
referências na janela lógica quando o campo é exibido usando um controle
RadioButtonGroup ou CheckBox. (Vejo“A janela Design de diálogo” ou
informações sobre esses tipos de controle.) Os controles CheckBox e
RadioButtonGroup não permitem a digitação direta de valores na caixa de diálogo de
uma instância do módulo. Em vez disso, um valor é fornecido selecionando um de
um conjunto predefinido de valores. No caso de botões de opção, isso é feito
selecionando um valor; no caso de caixas de seleção, o valor é definido marcando a
caixa com o valor Sim ou desmarcando a caixa com o valor Não.
Para referenciar operandos nesses campos, o Arena fornece uma caixa de diálogo de
referência especial para operandos. Para abrir esta caixa de diálogo ao editar uma
instância de módulo na janela lógica, coloque o ponteiro sobre qualquer um dos
valores em um controle RadioButtonGroup ou sobre um prompt CheckBox e clique
no botão direito do mouse. A caixa de diálogo aberta permite que você digite a
referência do operando para o grupo de botões de opções ou a caixa de seleção
usando qualquer um dos mecanismos descritos neste capítulo.
A Figura 6.8 mostra uma instância de um módulo Dispose no painel Basic Process.
A caixa de seleção determina se as estatísticas da entidade são geradas. A caixa de
diálogo foi aberta clicando com o botão direito do mouse no controle Record Entity
Statistics CheckBox. Um novo módulo com um operando denominado Estatísticas
da Entidade fornecerá o valor de Sim ou Não à caixa de seleção do módulo Registro.
Figura 6.8 Referência do operando para os controles RadioButtonGroup e CheckBox

Nota: Depois de estabelecer uma referência para um grupo de botões de opção ou

campo de caixa de seleção, se você clicar posteriormente em uma das opções de
um grupo de botões de opção ou na caixa de seleção, as informações de referência
serão removidas e o grupo de botões de opção ou a caixa de seleção será dado o
valor que você selecionou.

Nota: Para permitir que os desenvolvedores de modelos façam referência a um

operando em um controle ComboBox, a propriedade PickFromListOnly para caixas
de combinação é ignorada na janela lógica.

Comutadores nas instâncias do módulo da janela lógica

Conforme você altera os valores dos campos na caixa de diálogo de uma instância
do módulo na janela lógica, alguns dos campos podem controlar a exibição de
outros campos. Por exemplo, em uma instância de um módulo de Registro (no
painel Processo Básico), se você alterar o tipo de Contagem para Intervalo de
Tempo, os campos de valor e nome do contador serão desativados e os campos de
nome do atributo e nome da contagem serão ativados.
Se você definir uma referência de operando no campo que controla a exibição de
outros campos, todos os campos que dependem desse valor serão ativados. Isso
ocorre porque o valor real do campo de controle (por exemplo, o campo Tipo) não
será conhecido até que o módulo no qual ele está contido seja colocado em um
modelo e um valor seja fornecido ao operando que é referenciado.
No caso do exemplo do módulo Record, isso resulta em todos os operandos
controlados pelo valor Type sendo ativados e sobrepostos, como mostra a
Figura 6.9.
Figura 6.9 Caixa de diálogo da instância do módulo de registro com referência no
campo Tipo

Nota: Recomendamos que você defina os valores de qualquer campo que

possa ser alternado antes de fornecer um valor ao campo que controla sua
exibição.

Definindo a transferência de entidades para dentro e fora

de um módulo
Na Arena, as entidades são transferidas entre os módulos de uma das duas maneiras:
usando uma rota, transporte ou transporte entre estações (referido como transferência
de estação); ou usando uma conexão rotulada direta (referida como transferência
direta). Um módulo pode oferecer um ou ambos esses mecanismos para receber
entidades no módulo; Os módulos podem definir apenas um dos dois mecanismos
para qualquer local específico que envia entidades para fora do módulo.

TRANSFERÊNCIA DE ESTAÇÃO
Se você deseja permitir que entidades sejam transferidas para o seu módulo por uma
transferência de estação (ou seja, rota, transporte ou transmissão para uma estação
nomeada), a janela lógica do módulo deve conter uma instância de módulo que
define uma estação, como a Estação módulo no painel Blocos. Por exemplo, no
módulo Verificação de pedidos discutido anteriormente, podemos querer projetar o
módulo para permitir que as entidades sejam roteadas para uma mesa de verificação
de pedidos, representada em nosso módulo como uma estação. Na janela lógica,
poderíamos adicionar um módulo Station antes do módulo Process e referenciar um
novo operando, Order Desk, para estabelecer o nome da estação, como mostra a
Figura 6.10.
Figura 6.10 Instância do módulo Station no módulo Order Verification

Quaisquer entidades enviadas para uma instância do módulo Verificação de Pedido

por transferência de estação entrariam na instância do módulo Estação (na lógica
subjacente) e depois prosseguiriam para o módulo Processo.
Para especificar que as entidades devem ser transferidas para fora do seu módulo por
um módulo de transferência, coloque uma instância do módulo que permita a
transferência de estação (por exemplo, um módulo Deixar ou Rota no painel
Transferência Avançada ou Rota no painel Blocos) e faça referência aos operandos
apropriados do seu módulo. Quando um modelador usa uma instância do seu
módulo, as entidades prosseguem com a lógica que você definiu na janela lógica.
Quando uma entidade chega a um módulo na lógica que possui uma transferência de
estação, a entidade será enviada para a instância do módulo no modelo de simulação
que define a estação de destino.

TRANSFERÊNCIAS DIRETAS
No caso de transferências diretas, tipos especiais de operandos são usados para
permitir a conexão gráfica de módulos para representar o fluxo de entidades através
do modelo. O mecanismo para definir esses tipos de operando de ponto de entrada e
ponto de saída é descrito no capítulo "A janela de design da caixa de diálogo".
Quando um operando é definido como um operando de ponto de entrada ou ponto de
saída, um símbolo é colocado na visualização do usuário do módulo para permitir
que os modeladores conectem os módulos. O operando também pode ser exibido na
caixa de diálogo do módulo (geralmente com o prompt Label para pontos de entrada
ou Next Label para pontos de saída).
Na janela lógica, você identifica a instância do módulo que corresponde a um ponto
de entrada do seu módulo colocando uma referência de operando no campo
apropriado da instância. Por exemplo, se você deseja permitir transferência direta ou
transferência de estação no módulo Verificação de Pedidos, você pode definir um
novo tipo de operando de ponto de entrada chamado Desk Label. Na janela lógica,
esse operando seria referenciado pelo campo Label na instância do módulo Station
(no painel Blocks), como mostra a Figura 6.11.

Figura 6.11 Referência ao operando do ponto de entrada na instância do módulo da

janela lógica

Na caixa de diálogo da Figura 6.11, os dois métodos de transferência para a

Verificação de pedidos são permitidos: transferência de estação e transferência direta.
Um modelador que usa uma instância do módulo Order Verification tem a opção de
transferir entidades, roteando para a estação definida pelo operando Order Desk ou
conectando outros pontos de saída do módulo ao ponto de entrada definido pelo
operando Desk Label.
Nota: Recomendamos que, se você possui operandos de ponto de entrada e / ou
saída em um módulo, sempre exiba os operandos na caixa de diálogo do módulo (ou
seja, não os oculte). Se você definir o operando do ponto de entrada ou saída a ser
oculto, não será possível para uma instância do módulo referenciar operandos de
ponto de entrada ou ponto de saída se ele for usado na janela lógica da definição de
outro módulo.
Se você usar o modelo Arena na janela lógica de um módulo (painéis Processo
Básico, Processo Avançado e Transferência Avançada), o método de transferência
direta para inserir um módulo é mais complicado. O motivo é que os campos label
ou next label em todos esses módulos estão ocultos do usuário (não disponíveis para
referência aos valores do operando), mesmo que os pontos de entrada / saída estejam
visíveis. (Consulte o capítulo “A janela Design de diálogo” nos pontos de entrada ou
saída para obter mais informações.) Para que as entidades realmente entrem no
módulo usando uma referência de etiqueta, um módulo com uma etiqueta (no painel
Blocos) deve ser o primeiro módulo na lógica do modelo.
Normalmente, o módulo Delay da Blocks pode ser usado com um valor de duração
de 0,0, conforme mostrado na Figura 6.12.

Figura 6.12 Lógica do módulo com atraso: módulo 0.0 para acessar a etiqueta do
ponto de entrada 'Desk Label'
Referenciando Operandos Não Repetitivos de um Grupo
Repetitivo
As referências de operando feitas pelas instâncias do módulo em uma janela lógica
podem ser feitas a partir de um conjunto repetido de campos; isso é tratado de forma
idêntica às referências de campos não repetidos. (Veja o capítulo “A Janela de
Design de Diálogo”, começando em
página 77 para uma discussão de grupos repetidos e tópicos relacionados.)
Discutimos brevemente a adição de um recurso ao módulo Verificação de pedidos
e o uso do módulo Processo no painel Processo básico. O operando Nome do
funcionário (não repetitivo) será usado em um grupo de repetição de recursos.
Este exemplo criará uma tupla de grupo de repetição com o valor inserido pelo
usuário para o nome do recurso de funcionário. A lógica resultante teria entidades
aguardando para capturar uma única unidade de capacidade do recurso definido pelo
nome do funcionário do operando (veja a Figura 6.13).

Figura 6.13 Referência do operando no grupo de repetição

 Operandos não repetitivos também podem ser referenciados a partir de múltiplas
tuplas de um único grupo de repetição. Por exemplo, você pode estender o módulo
Verificação de Pedidos para capturar um supervisor quando uma entidade é
identificada como um pedido incompleto e também pode exigir que um trabalhador
responsável por encontrar os itens ausentes acompanhe o supervisor e receba o
pedido incompleto. . Nesse caso, convém solicitar ao modelador os nomes do
supervisor e do trabalhador, fornecendo operandos de módulo adicionais, Supervisor
e Nome do trabalhador. Ao fazer referência a cada um desses operandos em outro
módulo Process, sua lógica é tal que as entidades exigem os recursos de supervisor e
trabalhador antes de poderem continuar o processamento. Essa lógica é definida
adicionando as referências de operando em um módulo Process para conter duas
tuplas de grupo de repetição, a primeira tupla aproveita o recurso definido pelo
operando Supervisor e a segunda tupla aproveita o recurso definido pelo operando
Nome do Trabalhador. Este módulo Process é mostrado na Figura 6.14.

Figura 6.14 Múltiplas tuplas de grupos de repetição com referências de operando

130
Referenciando Operandos Repetitivos
Até agora, discutimos como fazer referência a operandos não repetitivos de
instâncias de módulo em uma janela lógica. Também é possível fazer referência a
operandos repetidos (ou seja, operandos que foram definidos como membros de um
grupo de repetição na janela de design da caixa de diálogo do módulo) a partir dos
módulos da janela lógica. Para fazer referência a um operando repetido, coloque o
nome do operando entre aspas, assim como é feito ao fazer referência a operandos
não repetitivos.
Para ilustrar isso, vamos considerar nosso módulo original de entrada de pedidos.
Este módulo será expandido para atribuir valores iniciais aos atributos da entidade e
enviar as entidades para a primeira atividade envolvida no processamento do pedido.
A caixa de diálogo para o módulo Entrada de pedidos pode ser projetada como mostra
a Figura
6.15 Esta caixa de diálogo contém:
 um operando para o tempo entre pedidos,
 um operando para o tamanho do pedido,
 um grupo de repetição de Atribuições de Atributo (com uma tupla aberta na
figura para mostrar seus operandos) contendo um operando de Atributo de
Pedido que define o atributo a ser atribuído e um operando Valor que especifica
o valor de atribuição, e
 um operando Próxima atividade que determina a atividade para a qual a
entidade será enviada.
Figura 6.15 Caixa de diálogo do módulo Order Entry

Para definir a lógica desse módulo, os módulos Criar, Atribuir e Rota no painel Blocos
podem ser usados. Na instância do módulo Create, os campos Tamanho do Lote e
Intervalo referenciam os operandos Tamanho do Pedido e Tempo Entre Pedidos,
respectivamente, como visto originalmente na Figura 6.2. Da mesma forma, o
campo Destino no módulo Rota faz referência ao operando Próxima Atividade do
módulo Entrada de Pedidos. Essas duas referências são do tipo descrito
anteriormente, em que um campo não repetitivo em uma instância do módulo
contém uma referência a um operando do módulo não repetitivo.
Para que os modeladores que usam o módulo Entrada de Pedido possam definir quantas
atribuições de atributo desejem, a instância do módulo Atribuir na janela lógica deve
aceitar todos os valores dos operandos Atributo e Valor do Pedido definidos em
cada instância da Entrada de Pedido módulo. Para estabelecer esse vínculo entre o
grupo de repetição na instância do módulo Assign e os operandos de repetição no
módulo Order Entry, insira uma única tupla de grupo de repetição no módulo Assign
e faça referência aos operandos do módulo de ordens de chegada, como mostra a
Figura 6.16.

132
Figura 6.16 Referência de campos de grupo de repetição a operandos de repetição

Sempre que um modelador insere uma nova tupla de grupo de repetição em uma
instância do módulo Entrada de pedidos, uma tupla correspondente é inserida na
instância do módulo Designar na janela lógica. Da mesma forma, à medida que um
modelador edita os dados (por exemplo, excluindo tuplas ou alterando valores), as
edições são refletidas na instância do módulo Designar.
MÚLTIPLAS REFERÊNCIAS AO REPETIR OPERANDO
Uma extensão desse uso de operandos repetidos é usar um único operando repetitivo
em várias referências em uma janela lógica. Nesse caso, cada referência criará uma
nova tupla na janela lógica correspondente a cada tupla que o modelador definir.
Para ilustrar esse conceito, voltemos ao módulo Verificação de pedidos discutido
anteriormente. Neste módulo, convém permitir que as entidades de ordem incompleta
capturem um número arbitrário de operadores (em vez de dois recursos específicos,
como foi projetado na Figura 6.14) e designem um novo estado para cada recurso do
operador após a captura.
O novo módulo de Verificação de pedidos contém um grupo de repetição com
operandos denominados Nome do operador e Novo estado. Na janela lógica, uma
instância de um módulo Seize é usada para definir a lógica para capturar os recursos
necessários. A referência do operando na instância do módulo Seize é mostrada na
Figura 6.17.

Figura 6.17 Instância do módulo Seize com referências

Para atribuir novos valores de estado aos recursos depois que eles são capturados, uma
instância do módulo Designar é colocada na janela lógica. No módulo Designar, como
um par de operandos repetidos deve ser referenciado, a mesma técnica é usada para
criar as referências do operando. Uma única tupla é inserida e os dois operandos do
módulo (Nome do Operador e Novo Estado) são referenciados, como mostra a Figura
6.18.
Figura 6.18 Designar instância do módulo com referências

Um modelador que usa uma instância deste módulo Verificação de Pedido pode
inserir uma tupla com os valores Operador de Recarga da Linha A e Preencher
Pedido Incompleto para os operandos de recursos e estados; uma segunda tupla pode
ter valores de operando Supervisor de Linha A e Problema de Ordem de Verificação.
O conteúdo resultante da janela lógica conteria duas tuplas de grupo de repetição na
instância do módulo Seize (uma vez que o módulo Verificação do Pedido possui
duas tuplas), com os nomes dos dois recursos preenchendo os campos Recurso. Da
mesma forma, como o módulo Atribuir na janela lógica contém referências a
operandos repetidos, duas tuplas de atribuição serão criadas com os pares de valores
para o recurso e o estado a serem atribuídos.
Uma limitação é colocada nas referências a operandos repetidos. Se você estiver
referenciando um operando repetido de um campo repetitivo em uma instância do
módulo, não poderá fazer referência a um operando repetido que pertença a um
grupo de repetição diferente. Esta regra se aplica ao campo específico que contém a
referência e a outros campos no mesmo grupo de repetição da instância do módulo.
Por exemplo, na instância do módulo Assign mostrada na Figura 6.18, as referências
ao operando seriam inválidas se os operandos Nome do Recurso e Novo Estado
pertencessem a diferentes grupos de repetição na definição do módulo.
COMBINANDO REFERÊNCIAS A OPERADORES DE
REPETIÇÃO E NÃO REPETIÇÃO
É possível combinar referências em um grupo de repetição, de modo que alguns dos
campos obtenham seus valores de operandos repetidos e alguns operandos não
repetitivos de referência. Nesse caso, os operandos repetidos definem quantas tuplas
devem ser criadas no grupo de repetição da instância do módulo da janela lógica, e o
valor do operando não repetitivo é incluído em cada tupla.
Por exemplo, se você deseja modificar o módulo Verificação de Pedido para
aproveitar um número arbitrário de recursos, mas deseja atribuir a todos os recursos o
mesmo novo valor de estado, use a mesma janela lógica conforme descrito
anteriormente (Seize and Assign with as mesmas referências de operando). No
entanto, o módulo Verificação de Pedido conteria um grupo de repetição apenas com
o operando Nome do Operador. O operando New State não seria repetitivo (ou seja,
na caixa de diálogo principal do módulo).
Um modelador que usa uma instância deste módulo Verificação de Pedido pode
definir que dois recursos são necessários (Operador de Recarga da Linha A e
Supervisor da Linha A) e fornecer um valor de Verificando Pedido Incompleto para o
novo campo de estado. Na janela lógica, duas tuplas de grupo de repetição serão
criadas em cada uma das instâncias do módulo Seize e Designar (porque ambas
referenciam o operando de Nome do Operador repetitivo). Na instância do módulo
Designar, o valor do estado, Verificando Pedido Incompleto, seria colocado nas duas
tuplas de atribuição.

Definindo pontos de saída repetíveis em um módulo

Os módulos construídos no Arena geralmente contêm um ou mais operandos de
ponto de entrada ou ponto de saída que permitem aos modeladores definir conexões
diretas para dentro ou para fora do módulo (em oposição às transferências de
estações, que são definidas especificando um nome de estação para definir uma
estação para roteamento, transporte ou transporte para um destino de estação).
Alguns módulos permitem um número indefinido de saídas, como o módulo Branch
do painel Blocks, que permite que uma ou mais entidades saiam com base nas
condições definidas pelo modelador. Se um módulo que você colocar em sua janela
lógica tiver um ponto de saída repetitivo, também será possível definir um ponto de
saída repetitivo para o seu módulo, de modo que o modelador usando seu módulo
possa selecionar quantas alternativas forem necessárias para controlar o fluxo da
entidade para fora do seu módulo. módulo.
Para definir um ponto de saída repetível, a mesma abordagem é usada para definir
operandos básicos repetidos. Na janela de design da caixa de diálogo, coloque um
tipo de operando TextBox em um formulário de caixa de diálogo de grupo de
repetição. Altere a propriedade LogicProperties do operando para ser um operando
do ponto de saída e conecte-o a um grupo de repetição. Na janela lógica, você faz
referência a esse operando em um campo de repetição, como o campo Enviar para
rótulo do grupo de repetição Tipos de ramificação no módulo Filial. Definindo um
o ponto de saída repetido na janela de design da caixa de diálogo faz com que um
objeto de ponto de saída repetível seja colocado na visualização do usuário do seu
módulo, como mostra a Figura 6.19.

Figura 6.19 Repetindo o ponto de saída

Por exemplo, se você estava criando um módulo Ordens de classificação que

representa um processo de classificação de pedidos, convém colocar um módulo
Process na sua janela lógica para representar o processo de examinar o pedido para
determinar a qual linha de preenchimento ele deve ser enviado. um módulo Branch
que despacha pedidos com base nas condições definidas pelo modelador. As
definições de operando para o seu módulo podem incluir operandos para o Nome do
classificador e o Tempo de classificação, bem como um conjunto repetido de
operandos que definem as condições que determinam a seleção das linhas de
classificação - Tipo de condição (um grupo de botões de opção com opções de If e
Else), Condição e o operando do ponto de saída Rótulo da linha de classificação. A
Figura 6.20 mostra uma caixa de diálogo de amostra contendo esses operandos.
Figura 6.20 Caixa de diálogo do módulo Ordens de classificação

Na janela lógica, o módulo Process faz referência aos operandos Nome do

classificador e Tempo de classificação. O grupo de repetição Tipos de ramificação do
módulo Filial faz referência aos três operandos repetitivos do módulo de linha de
classificação - Tipo de condição (referenciado clicando com o botão direito do mouse
no campo de grupo Se / Com / Mais / Sempre), Condição e Rótulo da linha de
classificação. Esta caixa de diálogo do módulo Branch é mostrada na Figura
6.21 Sempre que um modelador define uma nova tupla em uma instância do módulo
Ordens de Classificação, uma nova tupla é criada no módulo Filial subjacente e um
novo ponto de saída é criado na instância do módulo Ordens de Classificação e no
módulo Filial subjacente.
Figura 6.21 Módulo ramificado referenciando operandos repetidos incluindo
operando de ponto de saída

Módulos repetíveis
O recurso de módulo repetitivo permite criar um novo conjunto de lógica para cada
entrada ou tupla em um grupo de repetição. A interface e o procedimento básico são
descritos a seguir. Na janela lógica de um módulo, coloque um novo objeto em forma
de caixa (o repetidor do módulo) e associe-o a um objeto de grupo de repetição na
janela de design da caixa de diálogo. Coloque os módulos que você deseja repetir
dentro do repetidor do módulo. Conecte o repetidor do módulo a outra lógica, como
faria com qualquer outro módulo.
Para colocar um repetidor de módulo, abra a janela lógica do módulo e escolha o
objeto
> Repetidor de móduloopção de menu Mova o cursor de mira para a janela lógica
e clique uma vez para colocar um canto da caixa. Mova o ponteiro e clique
novamente para colocar o canto oposto da caixa.
Uma vez colocado, o repetidor do módulo possui pontos de conexão no interior e no
exterior da caixa. Os pontos de conexão externos são usados para conectar a caixa à
lógica não repetível externa à caixa, enquanto os pontos de conexão internos são
usados para conectar os módulos repetíveis dentro da caixa ao próprio repetidor do
módulo.
 Para usar o repetidor de módulo, coloque os módulos que você deseja repetir dentro
da caixa. A caixa pode ser redimensionada para permitir espaço adequado. Conecte
todos os módulos que você colocar dentro da caixa, como faria se estivessem fora da
caixa. Verifique se pelo menos um dos grupos de módulos dentro da caixa está
conectado a um ponto de conexão dentro da caixa.
Nota: Se você tiver problemas para conectar os módulos ao repetidor ou a partir do
módulo, acesse o menu Exibir> Snap e desative a opção Snap.

Para associar o repetidor do módulo a um grupo de repetição na janela de design

da caixa de diálogo, clique duas vezes em uma borda do repetidor de módulo para
abrir a caixa de diálogo Configurações do repetidor de módulo (mostrada na
Figura 6.22.) Digite o nome do grupo de repetição associado ou escolha na lista no
prompt Repetir nome do grupo.
Em seguida, escolha o tipo de lógica repetida. Existem dois tipos básicos: lógica que
se repete em paralelo ou lógica que se repete em série.
A lógica de repetição paralela especifica que cada repetição da lógica é independente
e representa um caminho lógico diferente. Se você deseja definir a lógica de repetição
em paralelo, deve conectar um ponto de saída repetível de um módulo (como Branch
ou Duplicate) ao ponto de entrada do repetidor de módulo. O exemplo 1 mostra como
definir a lógica de repetição paralela.
A lógica de repetição serial especifica que cada repetição da lógica é conectada,
uma após a outra, no mesmo caminho lógico. O exemplo 2 mostra como definir
lógica de repetição serial.
Por fim, escolha o número de saídas alternativas necessárias. Esta opção é usada para
fornecer caminhos lógicos adicionais a partir do repetidor do módulo. Por exemplo,
se um módulo dentro do repetidor de módulo tiver mais de um ponto de saída,
convém conectar um ponto de saída ao caminho lógico principal que sai do repetidor
de módulo e outro ponto de saída a um ponto de saída alternativo do repetidor de
módulo. O exemplo 3 mostra como você pode usar o campo Número de saídas
alternativas.
Para os próximos três exemplos, pontos de entrada e saída ocultos foram utilizados
nos módulos de entrada e saída, para que o módulo possa ser conectado a outros
módulos em uma janela de modelo. Por favor, consulte o capítulo “A Janela de
Design de Diálogo” para obter mais informações sobre pontos de entrada / saída e
operandos ocultos. Normalmente, não é recomendável ocultar os pontos de entrada /
saída, pois não há como referenciá-los em um módulo hierárquico.

140
Exemplo 1: Lógica Paralela
A Figura 6.22 mostra a janela lógica com um repetidor de módulo conectado a um
ponto de saída repetível de um módulo Branch (painel Blocks).

Figura 6.22 Janela lógica com repetidor de módulo

O Operand Explorer da janela de design da caixa de diálogo na Figura 6.23 reflete o

grupo Repetir tempos de rota com operandos Type e Route Time.

Figura 6.23 Operand Explorer na janela de design da caixa de diálogo com tempos de
rota de grupo repetidos
A Figura 6.24 mostra a caixa de diálogo Amostra com entrada de três tipos diferentes
e tempos de rota.

Figura 6.24 Caixa de diálogo de exemplo com tipos e tempos de rota

O código do modelo resultante é mostrado na Figura 6.25. O módulo Atribuir é

repetido uma vez para cada tupla no grupo de repetição de Tempos da rota.

Figura 6.25 Código do modelo

142
Exemplo 2: Lógica serial
A Figura 6.26 mostra o repetidor do módulo da janela lógica serial com um bloco
Atribuir e Atraso dentro.

Figura 6.26 Janela lógica com repetidor de módulo

Na Figura 6.27, o Operand Explorer da janela de design da caixa de diálogo

reflete processos de grupos repetidos com os operandos Tempo de Processo e
Estado Associado.

Figura 6.27 Operand Explorer na janela de design da caixa de diálogo com

processos de grupo de repetição
A caixa de diálogo de amostra na Figura 6.28 mostra a entrada de três tempos
de processo e estados associados diferentes.

Figura 6.28 Exemplo de caixa de diálogo com diferentes tempos de processo e

estados associados

O código do modelo resultante é mostrado na Figura 6.29. Os blocos Atribuir e

Atraso se repetem uma vez para cada tupla no grupo de repetição.

Figura 6.29 Código do modelo

Exemplo 3: Definindo Saídas Alternativas
Na Figura 6.30, a janela lógica mostra o repetidor do módulo com o bloco
Duplicado dentro. O número de saídas alternativas é 1 e uma conexão adicional
aparece na parte inferior do repetidor do módulo.

Figura 6.30 Janela lógica com repetidor de módulo

O Operand Explorer da janela de design da caixa de diálogo na Figura 6.31 mostra

o grupo de repetição Types and Quantities com os operandos Type and Quantity.

Figura 6.31 Operand Explorer na janela de design da caixa de diálogo com grupo
de repetição Tipos e quantidades
A Figura 6.32 mostra a caixa de diálogo de amostra com entrada de dois tipos
e quantidades diferentes.

Figura 6.32 Caixa de diálogo de amostra com entrada de dois tipos e quantidades
diferentes

O código do modelo resultante é mostrado na Figura 6.33. O bloco Duplicar se

repete uma vez para cada tupla no grupo de repetição.

Figura 6.33 Código do modelo

Opções personalizadas usando os botões de opção e
controles da caixa de seleção
Se você estiver usando um módulo na janela lógica que aceita apenas um
determinado conjunto de valores (por exemplo, um módulo que contém um
RadioButtonGroup ou CheckBox ou um controle ComboBox que possui uma lista de
valores), convém fornecer as mesmas opções aos modeladores usando seu módulo,
mas com um conjunto diferente de termos. Para fazer isso, você pode definir um
conjunto de operandos ocultos que contêm os valores exigidos pelo módulo em sua
janela lógica. Cada um dos operandos ocultos é ativado somente quando o valor
fornecido pelo usuário do seu módulo seleciona a opção personalizada
"correspondente" que você fornece. (Para obter uma descrição dos comutadores e
suas definições, consulte o capítulo "A janela do comutador".)
Por exemplo, convém criar um módulo de recebimento de matérias-primas
representando uma área de recebimento que pode ser usada em sistemas que movem
o material por empilhadeiras ou transportadores. A janela lógica do módulo pode
conter um módulo Deixar no painel Transferência avançada do modelo Arena para
transferir o produto para fora da área de recebimento. No módulo Deixar, as opções
que definem o tipo de transferência incluem Request Transporter e Access
Conveyor, respectivamente. No entanto, na sua caixa de diálogo, convém definir um
grupo de botões de opções (chamado Tipo de Transferência) que ofereça as opções
Usar Empilhadeira e Carregar no Transportador.
O controle RadioButtonGroup na caixa de diálogo é usado para obter uma seleção do
modelador; não será referenciado na janela lógica do módulo. Em vez disso, para
fornecer o valor necessário (Request Transporter ou Access Conveyor) ao módulo
Leave, dois operandos ocultos denominados Request e Access são usados, com
valores padrão de "Request Transporter" e "Access Conveyor", respectivamente.
Esses operandos possuem comutadores que controlam qual deles é usado na geração
da lógica do módulo. O comutador conectado ao operando oculto Request é definido
como True quando o tipo de transferência do operando possui o valor "Use Forklift";
Da mesma forma, o comutador conectado ao Access é verdadeiro quando o Tipo de
transferência tiver um valor de "Carga no transportador".
Na janela lógica, o campo Transfer Out no módulo Leave que define o tipo de
transferência fará referência a `Request``Access` para que qualquer operando ativado
forneça seu valor (Request ou Access) ao módulo Leave. Neste exemplo, as opções
Seize Resource e None no módulo Leave não podem ocorrer, uma vez que o módulo
Receiving não fornece uma maneira para o modelador definir o recurso Seize
Resource ou None.

147
Conexões do módulo
Usando conexões gráficas
Na janela lógica de um módulo, você coloca e conecta instâncias de módulo de
outros painéis de modelos. A interface para criar conexões de módulo é a mesma que
nas janelas de modelo - você pode estabelecer uma conexão gráfica entre o ponto de
saída de um módulo e o ponto de entrada de outro módulo (usando o menu Módulo>
Conectar ou o botão Conectar da barra de ferramentas) ou você pode digitar o rótulo
do módulo nas caixas de diálogo dos dois módulos (se estiver usando o painel
Blocos).
Ao trabalhar em uma janela lógica, o método gráfico de conectar módulos é
preferível, pois o Arena gera etiquetas de módulo exclusivas para conexões gráficas.
Se você digitar um rótulo específico para um ponto de entrada para um módulo na
janela lógica, efetivamente limitaria esse módulo a apenas uma única veiculação em
qualquer modelo (já que os rótulos dos módulos devem ser exclusivos em todo o
modelo).
Por exemplo, se você estiver criando um módulo de operação de impressão, poderá
colocar um módulo de atraso no painel Blocos na janela lógica do módulo. Se você
definir o campo Rótulo do módulo Atraso para ter um valor de Encadernação, o
módulo de operação de impressão poderá ser colocado apenas uma vez em qualquer
modelo (diretamente do seu modelo ou indiretamente de qualquer modelo que tenha
uma instância da sua operação de impressão) módulo na sua janela lógica). Se uma
segunda instância do módulo de operação de impressão fosse colocada em um
modelo, o Arena geraria um erro (o rótulo BookBinding é definido mais de uma
vez), porque o posicionamento de dois módulos com o mesmo rótulo cria uma
ambiguidade - se uma entidade for enviada para o rótulo BookBinding, não há regra
para definir qual dos dois módulos se destina. Por causa disso,
148
Definindo várias conexões a partir de um único ponto de
saída
Uma diferença entre conectar módulos em uma janela lógica e conectar módulos em
uma janela modelo é que as janelas lógicas permitem que várias conexões deixem o
mesmo ponto de saída. As janelas de modelo restringem cada ponto de saída a ter
apenas uma conexão (seja por uma conexão gráfica ou por um valor especificado
para o operando do rótulo de saída). No entanto, como as janelas lógicas permitem
caminhos alternativos da lógica controlados por comutadores de módulos, é
necessário permitir várias conexões.(Veja “Módulo de comutação instâncias ”na
página 152 para uma discussão dessa técnica.)
Para definir várias conexões gráficas deixando o mesmo ponto de saída, adicione
cada conexão desejada ao ponto de saída. Por exemplo, a Figura 6.34 mostra um
módulo de Lote

149
instância com duas conexões emanadas de seu ponto de saída, uma para um módulo
de registro e a outra para um módulo de atribuição. Certifique-se de que os vários
módulos conectados a um único módulo tenham comutadores conectados, para que
logicamente apenas um seja gerado no modelo subjacente.

Figura 6.34 Várias conexões a partir de um único ponto de saída

Repetindo pontos de saída na janela lógica

Outra diferença entre as conexões nas janelas modelo e lógica refere-se à repetição
de pontos de saída. Na janela lógica, você pode criar uma referência de operando
para um ponto de saída repetitivo (conforme descrito em“Referenciando Dados do
Módulo” na página 116), nesse caso o modelador que usa seu módulo determina
para onde as entidades devem ser enviadas para cada ponto de saída individual. Ou
você pode conectar um único ponto de saída repetitivo ao ponto de entrada de outro
módulo na janela lógica, para que todas as entidades enviadas pelo módulo na janela
lógica sigam para o mesmo módulo seguinte.
A janela lógica fornece a opção adicional de conectar todos os pontos criados
por um ponto de saída repetido ao mesmo módulo. Para definir esse tipo de
conexão, conecte o ponto de saída repetitivo (definido pela inserção de uma
tupla no grupo de repetição de um módulo) ao ponto de entrada de um módulo
na janela lógica.
Por exemplo, você pode estar criando um módulo que representa a etapa final do
processamento para a produção de metal corrugado. Alguns tipos de peças que
passam por essa etapa exigem um ajuste final; em todos os casos, as peças serão
estampadas (após o corte para as que são cortadas). A caixa de diálogo deste módulo
pode solicitar ao modelador que liste todos os tipos de peça
 que exigem corte, o tempo para aparar as peças (supondo que seja o mesmo para
todos os tipos de peça), o nome da máquina de estampagem e o tempo de
estampagem. A Figura 6.35 mostra a caixa de diálogo do módulo deste exemplo.

Figura 6.35 Exemplo de caixa de diálogo Metal corrugado

O Operand Explorer da janela de design da caixa de diálogo para este módulo,

mostrado na Figura 6.36, define um grupo de repetição Trimped Part Types contendo
o único operando que define quais tipos de peça devem ser aparados (Part Type). Os
três operandos que completam a caixa de diálogo solicitam a hora de aparar, o nome
da máquina de estampagem e a hora de carimbar.

Figura 6.36 Operand Explorer na janela de design da caixa de diálogo do

exemplo de Metal corrugado

150
Na janela lógica, um módulo Branch do painel Blocks pode ser usado para
determinar se as entidades devem ser enviadas para o processo de ajuste
(representado por um simples módulo Delay). Cada vez que o modelador cria uma
nova tupla no grupo de repetição Tipos de peças aparadas, um novo ponto de saída
será criado no módulo Filial; todos esses pontos de saída serão conectados
automaticamente ao módulo Delay. Para definir isso na janela lógica, a primeira
tupla inserida no grupo de repetição Branch Types do módulo Branch é definida
como mostra a Figura 6.37 - o tipo de condição é selecionado para If e a condição
compara o operando Part Type (que está repetindo em o módulo de metal corrugado)
com o valor de um atributo de entidade PartType (que pode ter sido inicializado em
um módulo de entrada de pedidos).

Figura 6.37 Módulo de ramificação na janela lógica de exemplo de Metal Corrugado

O ponto de conexão para a primeira tupla do módulo Branch é conectado ao módulo

Delay, para que todas as entidades que tenham um valor do atributo PartType igual a
um dos tipos de peça definidos pelo modelador atrasem o tempo de corte; o módulo
Delay está conectado ao módulo Process do processo de estampagem. Para concluir
esta definição de módulo, uma segunda tupla é inserida no módulo Ramificação com
um Tipo de ramificação igual a Else. Este ponto de saída é conectado diretamente ao
módulo Process representando o processo de estampagem. A janela lógica completa
é mostrada na Figura 6.38.
 Figura 6.38 Janela lógica para exemplo de metal corrugado

Essa técnica - conectando um ponto de saída repetitivo a um único módulo -

também é frequentemente usada em conjunto com o módulo de atribuição
condicional descrito em "Usando Módulos de utilitários da Arena (de utlarena.tpo)
”na página 156.

Alternando instâncias do módulo

Um dos aspectos principais dos modelos do Arena é a capacidade de definir lógica
de modelo alternativa que é controlada pelos valores que um modelador fornece
para os operandos do módulo. O mecanismo para definir que certas partes da
lógica de um módulo devem ser incluídas apenas em circunstâncias específicas é
conectar um comutador a um módulo na janela lógica. O capítulo "A janela do
switch" descreve como os switches são definidos.
Os switches são particularmente importantes devido ao efeito que seu uso pode ter
na velocidade de uma simulação. Se um módulo usa comutadores para remover
caminhos desnecessários da lógica, o modelo de simulação resultante representa a
menor lógica necessária, dadas as opções que o modelador selecionou. Se os
switches não fossem um recurso essencial do desenvolvimento de modelos, todas as
decisões sobre qual lógica deveria ser usada precisariam ser tomadas durante a
simulação executada por cada entidade que chegasse a um módulo. Ao projetar um
módulo, é útil planejar quais alternativas você fornecerá e esboçar como essas
opções podem controlar a lógica gerada pelas instâncias do módulo na janela lógica.

152
 Conectando e Desconectando Interruptores
Na janela lógica, para conectar um comutador a um módulo, você seleciona o módulo
(clicando na alça) e seleciona o item de menu Objeto> Alternar> Anexar ou
clique no botão Attach Switch na barra de ferramentas Template Development. É
aberta uma caixa de diálogo contendo uma caixa de combinação na qual a opção
desejada deve ser inserida (digitando seu nome ou selecionando-o na lista
suspensa). O identificador do módulo se expande para incluir o nome do comutador
conectado, entre colchetes (por exemplo, [SwCount]). A Figura 6.39 mostra um
exemplo de conexão de um comutador a um módulo Record no painel Processo
básico.

Figura 6.39 Anexando um comutador a uma instância do módulo

Para remover uma opção conectada a um módulo, selecione o módulo e selecione a

opção Desanexar no menu Objeto> Alternar. Se você deseja conectar o mesmo
comutador a vários módulos ou desconectar comutadores de vários módulos,
selecione o conjunto de módulos desejado (usando SHIFT + Clique para selecionar
um grupo de módulos individuais ou selecionando todos os módulos de uma região
na caixa da janela) e clique no botão da barra de ferramentas Attach Switch ou
selecione a opção apropriada no menu Switch.
Nota: Um módulo na janela lógica pode ter apenas um único switch conectado a ele.
Se você tiver condições complexas envolvendo vários comutadores, defina um novo
comutador na janela do comutador com uma definição representando as condições
e conecte-o ao módulo da janela lógica.
Efeito de comutadores na janela lógica
Conforme descrito anteriormente neste capítulo, trabalhar na janela lógica de uma
definição de módulo é muito semelhante à criação de um modelo de simulação em
uma janela de modelo Arena. Você anexa painéis de modelo à barra de projetos e
seleciona, coloca, edita e conecta instâncias do módulo. Se você deseja definir
caminhos lógicos alternativos a serem incluídos ou removidos do modelo com base
nos valores dos operandos do módulo, defina comutadores na janela do comutador e
conecte-os às instâncias do módulo na janela lógica.
Quando um módulo é colocado ou editado em uma janela de modelo, os switches são
avaliados como true ou false com base nos valores do operando do módulo. Se o
modelo for verificado quanto à integridade ou se for iniciada uma simulação, a janela
lógica do módulo será examinada; somente as instâncias do módulo na janela lógica
que não possuem um comutador conectado ou que possuem um comutador
verdadeiro são incluídas na lógica do modelo de simulação. Se um módulo na janela
lógica tiver um comutador falso conectado, a janela lógica será tratada como se o
módulo, assim como quaisquer conexões diretas dentro ou fora do módulo, não
existisse.
Por exemplo, se você estiver construindo um módulo que representa pontos de coleta
para o serviço de pacotes noturnos, o módulo poderá ser usado tanto em caixas de
coleta de autoatendimento quanto em escritórios de coleta com equipe. Em qualquer
instância específica em que o módulo for usado, apenas um tipo (autoatendimento ou
escritório) será aplicado; todas as entidades que chegam ao módulo serão tratadas de
uma maneira ou de outra. A janela de design da caixa de diálogo para este módulo
pode definir um operando de seleção, Tipo de coleção, com opções de
Autoatendimento ou Escritório com equipe. Na janela do switch, um switch SwSelf é
adicionado com uma definição de `Tipo de coleção` ==” Autoatendimento ”. Um
segundo comutador, SwStaffed, tem uma definição `Tipo de coleção` ==” Pessoal. ”
Consulte o capítulo "A janela do switch" para obter mais informações sobre a
definição de switches do módulo.
A janela lógica do módulo de coleção de pacotes define os dois caminhos possíveis da
lógica. No caso de pontos de coleta de autoatendimento, talvez você queira que os
clientes executem a lógica: Estação, Atraso, Rota. No entanto, para escritórios com
equipe, um módulo Processo pode ser usado para representar a disponibilidade dos
trabalhadores da coleta de pacotes, para que os clientes executem: Estação, Processo,
Rota. Nos dois casos, os módulos Estação e Rota podem conter as mesmas
informações, independentemente do tipo de ponto de coleta. O comutador SwSelf é
conectado ao módulo Delay para que ele seja incluído na lógica do modelo somente
quando SwSelf for True; Da mesma forma, SwStaffed é anexado ao módulo Process.
A janela lógica completa pode ser definida como mostrado na Figura 6.40.
Figura 6.40 Janela lógica com módulos comutados oferecendo duas alternativas

O módulo da estação possui duas conexões ao seu ponto de saída. Embora isso
seja inválido em uma janela de modelo (ou seja, cada ponto de saída em uma
janela de modelo deve ter exatamente uma conexão), as janelas lógicas permitem
várias conexões porque os comutadores podem excluir efetivamente as conexões,
dependendo dos valores dos operandos do módulo.
Como projetista do módulo, você deve garantir que os comutadores que você definiu
e anexou às instâncias do módulo na janela lógica permitam que exatamente uma
conexão esteja ativa (ou seja, não desativada) de cada ponto de saída em qualquer
uso possível do seu módulo . Em módulos com comutadores, é muito útil testar
cuidadosamente cada alternativa da lógica do modelo (com base na variedade de
valores possíveis para os operandos do módulo) para garantir que a janela lógica
esteja correta.
Não há restrições na complexidade dos módulos que devem ser alternados em
uma janela lógica. O exemplo do ponto de coleta de pacote noturno seleciona uma
das duas alternativas, em que cada alternativa inclui apenas um único módulo.
Qualquer alternativa pode envolver muitos módulos com comutadores adicionais
que fornecem opções adicionais. A definição de módulos, como o módulo Deixar
(painel Transferência avançada), pode envolver dezenas de comutadores que
controlam a exibição de operandos na caixa de diálogo do módulo e as instâncias
do módulo na janela lógica.
Uma pequena extensão do exemplo do ponto de coleta de pacotes pode ser perguntar
ao modelador se os clientes que chegam aos pontos de coleta de autoatendimento
podem recusar (ou seja, não enviar o pacote nessa caixa de coleta) com base em
alguma condição. A lógica para representar esta nova opção aparece na Figura 6.41.
Figura 6.41 Janela lógica para o módulo Collection Collection com opção de
impedimento do cliente

Um novo caminho lógico foi adicionado emanando do módulo Station. Nesse

caminho, um módulo Decide foi colocado com dois pontos de saída: um conectado a
um novo módulo Delay e outro conectado diretamente a um módulo Route (para
recusar clientes). Cada um dos novos módulos possui um novo switch, SwBalk,
conectado. Essa opção pode ser definida com base em um novo operando da caixa de
seleção, Balk Customers, com o valor Sim. O operando Balk Customers, por sua vez,
só poderia ser ativado quando o SwSelf for verdadeiro, pois o módulo deve perguntar
se os clientes devem recusar uma condição apenas para caixas de coleta de
autoatendimento.
Para verificar se o módulo está definido corretamente, cada ponto de saída contendo
várias conexões deve ser rastreado para garantir que exatamente uma das conexões
seja ativada para qualquer valor dos comutadores dos módulos SwSelf, SwStaffed e
SwBalk. O único módulo que contém várias conexões com um único ponto de saída
é o módulo Station. Ao rastrear os módulos ativados para cada uma das
combinações de valores dos comutadores (ativado e desativado para cada um dos
três comutadores), você pode garantir que o seu módulo gere lógica de módulo
válida em qualquer uso possível.

Usando os módulos utilitários da Arena (de utlarena.tpo)

O Arena fornece um arquivo de painel de modelo de utilitário privado, denominado
utlarena.tpo, que contém um conjunto de módulos projetados exclusivamente para
uso em janelas lógicas de definição de módulo. (Consulte o capítulo “Janela
Modelo” para obter informações sobre modelos particulares.) Por ser um modelo
privado, não pode ser anexado para uso no modelo
janelas. As seções a seguir descrevem os módulos contidos neste painel de
modelos e ilustram seu uso.
MÓDULO ESCONDIDO
Um módulo no arquivo do painel de modelo utlarena.tpo, o módulo Oculto, foi
projetado especificamente para ajudar na definição de janelas lógicas que contêm
comutadores nas instâncias do módulo. Este módulo não gera nenhuma lógica ou
elemento do modelo. (Consulte o capítulo "Elementos" para obter informações
sobre elementos.) Ele contém pontos de entrada e pontos de saída para permitir que
outros módulos se conectem e saiam dele.
O módulo oculto é usado para casos em que uma ou mais das alternativas a serem
ativadas / desativadas na janela lógica não geram nenhuma lógica de modelo. Nesses
casos, uma conexão deve ser formada para mostrar o fluxo lógico desejado (porque
você não pode conectar um comutador a uma conexão diretamente), mas não há
instância de módulo na qual um comutador possa ser conectado para indicar quando o
caminho alternativo deve ser ocupado.
Por exemplo, voltemos ao módulo noturno de coleta de pacotes ilustrado na Figura
6.40. Podemos adicionar uma opção para os tipos de autoatendimento de escritórios de
pacotes para contar o número de clientes que deixaram os pacotes. Um comutador,
SwCount, pode ser definido como verdadeiro se o modelador indicar que essa
contagem deve ser coletada. Outra opção, SwNoCount, pode ser definida como
verdadeira quando nenhuma contagem deve ser feita.
A lógica desejada para esta opção adicional, mostrada na Figura 6.42, inclui uma
instância de um módulo Count após o atraso somente quando o modelador indica que
a contagem deve ser coletada (ou seja, SwCount é True). Por outro lado, se nenhuma
contagem for feita, a segunda conexão do módulo Delay deve enviar entidades
diretamente para o módulo Route. No entanto, se uma conexão fosse adicionada
diretamente do módulo Delay ao Route, a lógica resultante teria duas conexões
válidas se o modelador escolhesse contar clientes (ou seja, a conexão com o módulo
Count e a conexão com o módulo Route). Para evitar isso, o módulo oculto é
adicionado entre o atraso e a rota, para que qualquer uso desse módulo possa ter
apenas uma única conexão ativada a partir do ponto de saída do módulo atraso.
Figura 6.42 Janela lógica usando a instância do módulo oculto

Nota: O módulo Hidden_All_Types fornece a mesma funcionalidade que o módulo

Hidden com opções adicionais para os vários tipos de pontos de entrada e saída, para
que você possa conectá-lo a qualquer outro módulo.
O MÓDULO DE ATRIBUIÇÃO CONDICIONAL
O modelo utlarena.tpo contém outro módulo, o módulo de atribuição condicional,
que pode ser usado apenas em janelas lógicas. Esse módulo pode ser pensado como
uma combinação de um módulo de ramificação (painel Blocos) e um módulo de
atribuição (painel Processo básico), em que cada ramificação que sai do módulo de
atribuição condicional pode executar sua própria atribuição. A caixa de diálogo do
módulo para o módulo de atribuição condicional é mostrada na Figura 6.43.

Figura 6.43 Caixa de diálogo Módulo de atribuição condicional

O módulo de atribuição condicional pode ser útil nos casos em que o sistema que
você está representando possui um número desconhecido de condições que
determinam os valores que devem ser aplicados a uma atividade específica.
Por exemplo, no módulo que representa o escritório de pacote noturno, convém
permitir que os modeladores especifiquem diferentes condições a serem testadas
sobre clientes de autoatendimento e definir tempos de atraso individuais com base
na condição. Para representar isso na janela lógica, você pode usar um módulo de
atribuição condicional que faça referência ao operando da condição e atribua um
atributo (DelayType) ao tempo de atraso especificado pelo modelador para cada
condição. A atribuição condicional
 O módulo se conecta ao módulo Delay, que usa o atributo DelayType (em vez de
um operando do módulo) para especificar o tempo de atraso. Essa lógica é
mostrada na Figura 6.44.

Figura 6.44 Uso do módulo de atribuição condicional na janela lógica

Definindo Rastreio de Módulo

O Arena fornece um rastreamento da lógica executada pelas entidades durante uma
execução de simulação. No nível mais baixo, o bloco SIMAN Trace fornece
informações detalhadas e passo a passo sobre os processos realizados para
representar a lógica de um módulo. Como designer de módulo, você não precisa
fornecer nenhuma informação adicional para que esse tipo de rastreio seja ativado.
Se um modelador usando seu modelo desejar visualizar o bloco Trace, o Run> Run
Control
> Comando abre uma janela de comando na parte inferior da tela. O botão
Alternar rastreamento pode ser usado para ativar ou desativar o rastreamento do
bloco SIMAN.
É possível definir mensagens de rastreio adicionais específicas do módulo, inserindo
os módulos Trace (no painel Blocks) em qualquer lugar da janela lógica que permita
conexões de entrada e saída padrão. (Consulte o bloco Rastrear na Ajuda para obter
uma descrição do módulo e seus campos.)

160
 Por exemplo, no módulo do escritório de pacotes descrito na seção anterior, você
pode adicionar mensagens de rastreamento indicando quando as entidades saem do
módulo. Se as mensagens de rastreio devem ser diferentes para cada tipo de módulo
(ou seja, autoatendimento ou pessoal), os módulos Trace individuais são adicionados
com os comutadores apropriados anexados, como mostra a Figura 6.45.

Figura 6.45 Janela lógica do módulo com módulos Trace

Regras e diretrizes de definição de lógica

As regras a seguir resumem pontos importantes relacionados à definição da
lógica de um módulo.
 Os módulos não podem conter instâncias do mesmo painel de modelos ou
qualquer modelo que tenha o modelo que está sendo editado anexado a ele.
 Os pontos de entrada e saída das instâncias do módulo na janela lógica devem
estar conectados ou fazer referência a um operando do módulo. (O operando do
ponto de entrada para os módulos que criam entidades e pontos de saída de fila
sem retorno são exceções; eles podem ser desconectados em uma janela lógica.)
 Se uma instância do módulo na janela lógica tiver campos obrigatórios, você
deverá fornecer valores a eles. Se um campo obrigatório contiver uma referência
simples a um operando do seu módulo, o operando referenciado deverá ser
definido conforme necessário na janela de design da caixa de diálogo do seu
módulo. Se o valor do campo obrigatório for definido usando várias referências
de operando, você deve garantir que, sob qualquer combinação válida
dos valores inseridos por um modelador (para o seu módulo), o campo na instância
do módulo não pode ficar em branco.
 Se você referenciar um operando em uma instância do módulo, verifique se o
tipo de dados do operando mencionado corresponde ou é mais restritivo que o
tipo de dados do campo no módulo. Por exemplo, você não deve definir um
operando com um tipo de dados de expressão para um campo de capacidade de
recurso que aceite apenas valores inteiros.
 Se uma entrada ou ponto de saída específico for referenciado mais de uma vez
na janela lógica, os comutadores deverão ser conectados aos módulos que
contêm as referências, para que seja possível apenas a ativação de um dos
módulos.

162
7 A janela de exibição do

usuário
A visualização do usuário de um módulo é a exibição que aparece quando um
modelador coloca o módulo em uma janela de modelo. A visualização do usuário
sempre contém um identificador de módulo. Ele também pode conter objetos
relacionados ao módulo (como pontos de entrada ou saída ou operandos exibidos)
criados com base nas informações fornecidas na janela de design da caixa de
diálogo. Você também pode adicionar objetos de desenho e animação à
visualização do usuário.
Para editar a visualização do usuário de uma definição de módulo, selecione o
módulo na janela do modelo. lista de módulos e selecione Janela> Exibição do usuário ou
clique na janela Exibição do usuário
botão na barra de ferramentas Desenvolvimento de modelos. Isso abre uma janela
de visualização do usuário, conforme ilustrado na Figura 7.1.

Figura 7.1 Janela de visualização do usuário

A região de desenho da janela de visualização do usuário é idêntica à região de uma

janela de modelo; por exemplo, sua visualização inicial exibe objetos do mesmo
tamanho que a visualização inicial de uma janela de modelo. Outras informações
relacionadas aos tamanhos de objetos, como proporções de texto ou espaçamento de
grade, também são definidas nas mesmas unidades mundiais usadas nas janelas do
modelo. (Consulte a Ajuda online para obter informações adicionais sobre as janelas
do modelo.)
Nota: Se você alterar o nível de zoom da visualização do usuário, lembre-se de retornar
à visualização inicial para garantir que os objetos que você colocou na visualização
do usuário sejam dimensionados conforme você deseja que apareçam na
visualização padrão em uma janela de modelo.
 7 • TELE USER VIEW WINDOW

Instâncias do módulo
Quando uma instância do módulo é colocada em uma janela de modelo ou lógica, os
objetos que estão na janela de visualização do usuário da definição de módulo são
copiados na janela de destino (ou seja, modelo ou lógica). O local em que o
modelador clicou para colocar o módulo é usado para posicionar o canto superior
esquerdo da alça do módulo. Outros objetos de visualização do usuário são
organizados em torno da alça nos tamanhos e posições relativos definidos na janela
de visualização do usuário.
Após serem colocados em um modelo, os objetos na visualização do usuário do
módulo podem ser reposicionados individualmente pelo modelador. Além disso, as
características dos objetos de desenho e animação podem ser alteradas; esses objetos
também podem ser recortados, copiados, colados, excluídos ou duplicados. Por
exemplo, um objeto de animação de fila que acompanha o módulo Process (do
painel Basic Process da Arena quando a ação inclui uma apreensão) pode ser
alterado de seu tipo de linha padrão para um tipo de ponto ou pode ser reposicionado
em relação ao local de manipulação do módulo.
Nota: Quando o identificador de uma instância do módulo é movido, os objetos de
exibição do usuário são realocados com o identificador. Na janela de visualização
do usuário da definição do módulo, no entanto, a realocação do identificadornão
mova os objetos de exibição do usuário.

Objetos relacionados ao módulo

Ao definir módulos, certos objetos são adicionados à janela de visualização do
usuário do módulo automaticamente. Esses são:
 a alça do módulo,
 pontos de entrada,
 pontos de saída e
 todos os operandos que possuem sua propriedade InUserView definida como
True no design da caixa de diálogo.
A Figura 7.2 mostra a visualização do usuário de uma instância do módulo Process
no painel Basic Process. Inclui uma alça (Processo #), ponto de entrada, ponto de
saída. Quando o nome do identificador do módulo, Process #, é alterado, o
identificador do módulo também assume esse novo nome. Vejo“A caixa de diálogo
Opções de texto do módulo” na página 165 Para maiores informações.

164
Figura 7.2 Visualização do usuário da instância do módulo Process

A alça do módulo
O identificador do módulo refere-se ao nome que aparece quando o módulo é
colocado em uma janela modelo ou lógica. O Arena coloca automaticamente um
objeto de identificador de módulo (exibindo o nome do módulo, por padrão) na
janela de exibição do usuário de cada módulo quando o módulo é criado. Você pode
alterar o nome do identificador clicando duas vezes no objeto de identificador do
módulo na janela de visualização do usuário (consulte“A caixa de diálogo Opções de
texto do módulo caixa ”na página 165) Um identificador de módulo pode conter no
máximo 32 caracteres.
Como todos os módulos devem ter exatamente um identificador de módulo, o objeto
identificador não pode ser cortado, copiado, duplicado ou excluído da janela de
visualização do usuário; também não pode ser agrupado com outros objetos.

A caixa de diálogo Module Text Options

O identificador do módulo, por padrão, exibe o nome do módulo. O nome pode ser
alterado clicando duas vezes no identificador do módulo para abrir a caixa de diálogo
Opções de texto do módulo. Você pode alterar a sequência de texto especificada ou
desmarcar a caixa de seleção Usar sequência de texto para identificador de módulo e
especificar um nome de operando que aparecerá como identificador de módulo.
Você notará que, nos módulos de modelo Arena (processo básico, processo
avançado, transferência avançada), quando você coloca um módulo em uma janela
de modelo, o identificador é o nome exclusivo dado a esse módulo. Por exemplo,
quando o módulo Process é colocado, ele se torna o Processo 1. A segunda instância
se torna o Processo 2, a terceira é o Processo 3 e assim por diante. Esses nomes são
baseados no nome do módulo, que pode ser alterado pelo usuário na caixa de
diálogo Processo. Portanto, o identificador do módulo nem sempre é Processo, mas
baseia-se na entrada do nome do usuário no operando Nome do módulo.
A fonte do identificador do módulo, o estilo da fonte e o tamanho da fonte são
definidos no tamanho padrão para que todos os módulos do Arena tenham uma
interface consistente para acessar os dados do módulo. Desmarcando a caixa de
seleção Usar fonte padrão, no entanto, você pode alterar o tamanho, estilo e fonte da
alça do módulo. Além disso, a linha, o texto e a cor do preenchimento podem ser
alterados usando a barra de ferramentas Cor.

Figura 7.3 Caixa de diálogo Opções de texto do módulo (com String de texto ou Nome
do operando usado para o identificador do módulo)

Pontos de entrada e saída

Ponto de entradae os objetos de ponto de saída na visualização do usuário são
criados automaticamente pelo Arena para cada operando de ponto de entrada e
ponto de saída definido na janela de design da caixa de diálogo. Os objetos do ponto
de entrada e saída fornecem um meio gráfico de conectar o módulo resultante a
outros módulos.
Os pontos de entrada e saída podem ser movidos para qualquer lugar na janela de
visualização do usuário. Quando você seleciona um ponto de entrada ou saída, o
nome do operando para esse ponto é mostrado abaixo do objeto gráfico (para que
você possa distinguir os pontos um do outro se tiver mais de um operando do ponto
de entrada ou saída).
A aparência dos pontos de entrada e saída depende do tipo de ponto. A Figura
7.4 mostra cada tipo de ponto de entrada e saída em uma visualização do
usuário (incluindo um ponto de saída repetível), com o tipo de ponto rotulado
ao lado do ponto de entrada ou saída gráfico.
A orientação de um objeto de ponto de saída não repetível pode ser girada
clicando duas vezes no objeto. Os objetos do ponto de entrada e saída não
podem ser recortados ou copiados para a área de transferência, duplicados,
excluídos ou agrupados com outros objetos.
Nota: Se o operando que define o ponto de entrada ou saída for excluído da janela
de design da caixa de diálogo, o objeto correspondente será removido da janela de
visualização do usuário.
Figura 7.4 Tipos de pontos de entrada e saída

Você não pode anexar uma opção a um objeto de ponto de entrada ou saída na janela
de visualização do usuário. No entanto, você pode anexar uma opção ao operando na
janela de design da caixa de diálogo que define esse objeto. O comutador conectado
ao operando controlará se o objeto gráfico do ponto de entrada ou saída é exibido na
visualização do usuário do módulo.

Operandos exibidos
Operandos que foram definidos na janela de design da caixa de diálogo com a
propriedade InUserView definida como True criarão automaticamente um objeto de
texto (referido como um operando exibido) na janela de exibição do usuário.
(Consulte o capítulo “Janela Dialog Design” para obter informações sobre a
definição de operandos exibidos.) Na janela de exibição do usuário, o objeto de texto
que representa o operando exibido é mostrado como o nome do operando. Depois
que um modelador coloca o módulo em uma janela lógica de modelo ou modelo, o
texto muda para mostrar o valor do operando.
Você pode localizar o operando exibido em qualquer lugar da janela de exibição do
usuário. Você não pode cortar ou copiar objetos de operando exibidos na área de
transferência, excluí-los da janela de exibição do usuário ou agrupá-los com outros
objetos.
Por exemplo, a Figura 7.5 mostra uma janela de visualização do usuário para
um módulo de Chegadas de Trem contendo dois operandos exibidos - Yard e
Interarrival Time.
Figura 7.5 Janela User View com dois operandos exibidos

Se um modelador colocasse esse módulo e fornecesse os valores de Conway e

NORMAL (0.21,0.11) para os operandos, a visualização do usuário para a
instância do módulo exibia os dois valores de operando abaixo do identificador do
módulo, como mostra a Figura 7.6.

Figura 7.6 Operandos exibidos na instância do módulo

Como é o caso dos operandos dos pontos de entrada e saída, não é possível anexar
uma opção a esse tipo de objeto na janela de visualização do usuário. Em vez disso,
se ele aparece em uma janela de modelo ou lógica, é controlado pelo switch (se
houver) conectado ao seu operando associado na janela de design da caixa de
diálogo.
Além disso, objetos de desenho (discutidos na próxima seção) podem ser
agrupados; no entanto, eles não podem ser agrupados com a alça do módulo.
Você pode anexar opções para desenhar objetos na visualização do usuário. Se uma
opção estiver conectada, o objeto aparecerá apenas se a opção conectada for
avaliada como True.
Se você exibir um operando repetível na exibição do usuário, a exibição do usuário
mostrará o nome do operando (como é o caso dos operandos não repetíveis).
Quando um modelador usa o módulo, o Arena coloca os valores dos operandos em
uma lista vertical. Se um terceiro operando repetível, Características, for adicionado
ao módulo na Figura 7.5 e uma instância do módulo for criada com os valores
Número de carros, Programação e Número de motores, a exibição da instância
aparecerá como mostrado na Figura 7.7.

Figura 7.7 Instância do módulo com operando exibido repetível

Como o comprimento de um valor de operando normalmente é desconhecido (ou

seja, os modeladores podem fornecer valores curtos ou longos), os operandos
exibidos na visualização do usuário geralmente são colocados verticalmente.
 Desenhar objetos
Objetos de desenho (caixas, linhas, círculos etc.) podem ser colocados na janela de
exibição do usuário na barra de ferramentas Desenhar. Eles são adicionados da
mesma maneira que você adicionaria objetos de desenho a uma janela de modelo.
Escolha o objeto desejado na barra de ferramentas e coloque-o na janela. As camadas
ocultas e visíveis podem ser usadas para controlar se os objetos definidos na
visualização do usuário de um módulo aparecerão ou não durante uma execução de
simulação. (Consulte a Ajuda online para obter mais informações sobre essas
camadas.)
Os objetos de desenho podem ser recortados, copiados, colados, duplicados e
excluídos. Se os objetos forem recortados ou copiados para a área de transferência,
você poderá colá-los em qualquer janela que suporte objetos de desenho.
Após colocar um módulo em uma janela lógica de modelo ou modelo, um
modelador pode alterar as características ou excluir objetos de desenho que foram
fornecidos pela visualização do usuário do módulo.
Os objetos de desenho colocados na janela de visualização do usuário podem ter
uma chave anexadas (consulte “Usuário Exibir uso do comutador ”na página 173)
Nesse caso, o objeto aparecerá apenas se a opção anexada for avaliada como True.

Objetos de animação
Objetos de animação (por exemplo, filas, estações ou níveis) podem ser colocados na
janela de exibição do usuário na barra de ferramentas Animar. Eles são adicionados da
mesma maneira que você adicionaria objetos de animação a uma janela de modelo.
Escolha o objeto desejado na barra de ferramentas Animar, digite as informações
necessárias na caixa de diálogo do objeto e coloque o objeto na janela de exibição do
usuário.
Os objetos de animação podem ser recortados, copiados, colados, duplicados e
excluídos. Se os objetos de animação forem recortados ou copiados para a área de
transferência, você poderá colá-los em qualquer janela que suporte objetos de
animação.
Ao editar um objeto de animação, você pode especificar que ele seja nomeado
usando o valor de um ou mais operandos do módulo. Para criar esse vínculo entre a
caixa de diálogo do módulo e um objeto de animação, crie uma referência de
operando colocando o nome do operando entre aspas (`). Por exemplo, se você
estiver definindo um módulo no qual uma contagem é coletada com o operando
Nome do Contador que define o nome do contador, você pode colocar uma variável
de animação na visualização do usuário para mostrar o valor da contagem durante a

170
 execução da simulação. A entrada Expressão na caixa de diálogo variável pode ser
definida como NC (`Counter Name`), como mostra a Figura 7.8.

170
Figura 7.8 Referência do operando na caixa de diálogo variável de animação

Os operandos podem ser referenciados apenas nas entradas nas caixas de diálogo do
objeto de animação listadas na Tabela 7.1. Outras características do objeto de
animação podem ser definidas na visualização do usuário, mas não podem referenciar
operandos do módulo.
Além disso, se um objeto de animação fizer parte da visualização do usuário de uma
instância do módulo, a entrada listada na Tabela 7.1 não poderá ser alterada (ou seja,
esmaecida) pelo modelador, com exceção dos valores repetíveis (ou seja, expressões
de plotagem, entidade valores, estados de recursos ou valores globais).
As referências de operando nos objetos de animação seguem as diretrizes descritas
em“Referenciando Dados do Módulo” na página 116 do capítulo "A janela
lógica".
Não são permitidas referências a operandos repetidos em objetos de animação,
incluindo os casos em que o objeto de animação permite um conjunto repetido de
valores (ou seja, expressões de plotagem, valores de entidade, estados de recursos
ou valores globais).
Se um objeto de animação contendo referências de operando for copiado da janela
de exibição do usuário para a área de transferência e colado em uma janela de
modelo, as entradas que contêm referências serão alteradas para em branco (porque,
após serem coladas, o objeto de animação não faz mais parte de um módulo ) Se o
objeto de animação tiver um comutador conectado, o comutador será removido se o
objeto for colado em uma janela de modelo.
Os objetos de animação colocados na janela de exibição do usuário podem ter
comutadores conectados (consulte a próxima seção). Nesse caso, o objeto aparecerá
apenas se a opção anexada for avaliada como True.

Tabela 7.1 Características do objeto de animação que permitem referências de

operando
Objeto de animação Referência para permissão de entrada
Fila Identificador
Armazenamento Identificador
Estacionamento <nenhum>
Apreender a área <nenhum>
Estação Identificador
Interseção Identificador
Rota <nenhum>
Segmento Identificador
Distância Identificador
Rede Identificador
Variáveis Expressão, Formato
Relógios Unidades de tempo por hora, hora, minuto, segundo
Encontro Unidades de tempo por dia, mês, dia, ano, hora,
minuto, segundo
Níveis Expressão, Mínimo, Máximo, Expressão (Acum.),
Mínimo (para Expressão (Acum.)), Máximo (para
Expressão (Acum.)), # De Pontos, # de Pontos de
Distribuição, Largura
Histogramas Expressão
Parcelas Qualquer valor de propriedade textual (ou seja, você
pode inserir um valor no campo para especificar o valor
da propriedade)
Entidade Valor
Transportador Identificador
Recurso Identificador, Estado
Global Expressão, Valor

172
 Uso da chave User View
Dos objetos que podem aparecer na janela de exibição do usuário, apenas objetos de
animação e desenho podem ter opções anexadas. Uma opção contém uma expressão
condicional que é avaliada como Verdadeiro ou Falso. Se a condição da chave for
avaliada como Verdadeira, todas as animações ou objetos de desenho com a chave
conectada aparecerão na janela do modelo. Se False, esses objetos não aparecerão na
janela do modelo. Para obter mais informações sobre switches e seus usos, consulte o
capítulo "A janela do switch".
Para anexar uma opção a um objeto de animação na janela de exibição do usuário,
realce o objeto e escolha a opção de menu Objeto> Alternar> Anexar ou clique no botão
Anexar
Interruptor botão da barra de ferramentas (mostrado à esquerda). Digite o nome
do comutador ou selecione-o na lista suspensa na caixa de diálogo exibida.
Nota: Somente um único comutador pode ser conectado a qualquer objeto em uma
definição de módulo.

Por exemplo, se o módulo ilustrado na Figura 7.8 também contiver um comutador

chamado SwCount, esse comutador poderá ser anexado à variável na janela de
visualização do usuário, para que a variável de animação seja exibida apenas se uma
contagem estiver sendo coletada (ou seja, o valor SwCount é True). Nesse caso,
depois que o comutador é conectado, o nome da variável (conforme exibido na
janela de visualização do usuário) muda para mostrar o nome do comutador entre
colchetes, como mostra a Figura 7.9.

Figura 7.9 Variável de animação com o interruptor SwCount conectado

Para desanexar uma opção de um objeto, destaque o objeto desejado e escolha a opção
Objeto.
> Alternar> Desconectar opção de menu
Para conectar uma chave diferente a um objeto que já tenha uma chave conectada,
conecte a nova chave usando o procedimento descrito acima. O comutador anterior
será automaticamente desconectado e o novo comutador conectado.
Se vários objetos forem selecionados (ou seja, por meio de uma seleção de caixa ou
usando CTRL + Clique para selecionar objetos individuais), as ações de alternar
anexar e desanexar serão aplicadas a todos os objetos selecionados.
8 A janela do switch
Uma opção é uma construção que permite que um designer de modelo defina
variações de:
 os campos exibidos em uma caixa de diálogo do módulo,
 a lógica do modelo e os elementos gerados quando uma execução de simulação é
iniciada, ou
 os objetos de animação exibidos na visualização do usuário de um módulo.
Para controlar a aparência do módulo ou sua lógica de simulação subjacente,
defina os comutadores (usando a janela do comutador) e os anexe aos objetos
nas outras janelas da definição do módulo (design da caixa de diálogo, lógica,
visualização do usuário).
Como o próprio nome indica, um comutador pode ter um valor Verdadeiro
("ativado") ou Falso ("desativado"). Se um objeto tiver um comutador conectado,
o objeto será exibido ou incluído na lógica de simulação apenas se a condição do
comutador for avaliada como True.
O uso de comutadores permite capturar uma ampla gama de variações de algum
processo ou elemento do sistema em um único módulo, em vez de precisar definir
módulos semelhantes e separados para cada variação. Comutadores também podem
ser usados para controlar as informações apresentadas aos modeladores, para que
apenas os campos relevantes sejam exibidos.
Por exemplo, se um módulo que representa um caixa eletrônico (ATM) tiver uma
opção para o modelador indicar se os depósitos são aceitos no caixa eletrônico e um
modelador selecionar "Não", talvez não haja motivo para solicitar ao modelador
que defina o processamento tempo para depósitos. Nesse caso, um comutador pode
ser definido para desativar o operando do tempo do processo de depósito (ou seja,
removê-lo da caixa de diálogo) para qualquer caixa eletrônico que não aceite
depósitos. A lógica correspondente para o processamento de depósitos também
pode ser removida anexando o comutador às instâncias apropriadas do módulo na
janela lógica do módulo.
Neste capítulo, apresentamos os mecanismos para definir comutadores e interagir na
janela do comutador. Os capítulos “Dialog Design Window”, “Logic Window”,
“User View Window” e “Elements” descrevem os efeitos das opções em cada tipo
de construção de módulo e o mecanismo para anexar opções a objetos em uma
definição de módulo.

175
ARENA TEMPLATE DEVELOPER’S GUIDE

Definindo opções
Uma opção consiste em um nome e uma definição. A definição do comutador é
uma expressão condicional que é avaliada como Verdadeiro ou Falso. Pode conter
nomes de operandos, valores de operandos ou outros nomes de comutadores.
Um comutador pode ser anexado a qualquer um dos seguintes objetos em uma
definição de módulo:
 objetos de operando, grupo de repetição e caixa de diálogo na janela de design
da caixa de diálogo usando a propriedade SwitchName;
 instâncias de módulo na janela lógica; e
 animação e desenhar objetos na janela de exibição do usuário.
Um switch pode ser anexado a vários objetos do mesmo ou de tipos diferentes. Por
exemplo, um comutador chamado SwCount pode ser anexado a um operando na
janela de design da caixa de diálogo e a uma variável de animação na janela de
exibição do usuário. Quando a expressão condicional do comutador é avaliada, esses
objetos de lógica, operando ou animação se tornarão parte do modelo (se o
comutador for True) ou serão ignorados (se o comutador for False).
Os comutadores são definidos abrindo a janela do comutador do módulo e
especificando o nome e a definição do comutador. A janela de comutação de um
módulo é aberta clicando no módulo na lista Definições do módulo da janela do
modelo e selecionando a janela
> Mudar item de menu ou pressionando o botão Alternar janela na barra de
ferramentas Desenvolvimento de modelos.
Para criar uma nova definição de chave, clique no botão Adicionar na janela da
chave. Nesta caixa de diálogo, você especifica o nome e a definição da opção (ou
seja, a condição sob a qual a opção é True) e clique em OK. A Figura 8.1 mostra a
janela do comutador com uma única definição de comutador (SwDeposits).
Às vezes, é útil ao duplicar, copiar, colar ou excluir definições de comutador para
executar a operação em vários comutadores. Você pode selecionar várias opções
usando SHIFT + clique para selecionar um intervalo de opções ou usando CTRL
+ clique para adicionar opções individuais ao conjunto de seleção.

Figura 8.1 Janela Switch

 Mudar nomes
Um nome de opção pode consistir em um número ilimitado de caracteres
alfanuméricos. Quando os comutadores são referenciados ou anexados aos objetos do
módulo, o nome do comutador não é tratado com distinção entre maiúsculas e
minúsculas.
Nota: Em um módulo, o operando, o grupo de repetição, a caixa de diálogo e os
nomes dos comutadores devem ser exclusivos.

Alternar definições
Alternar definições são expressões condicionais que dependem dos valores
de outros operandos ou comutadores.
Ao referenciar um operando, o nome do operando deve estar entre aspas (`); para
comparar o operando com um valor, o valor deve ser colocado entre aspas duplas (“).
Por exemplo, para definir uma opção verdadeira se o operando Aceitar depósitos
(que pode ser exibido como uma caixa de seleção na caixa de diálogo do módulo)
tiver um valor Sim, a condição seria 'Aceitar depósitos' == ”Sim” ( conforme
mostrado na Figura 8.1).
Para usar o valor de outra opção em uma definição, digite o nome da opção (ou seja,
nenhum caractere especial é necessário para identificar o nome da opção).
A Tabela 8.1 resume as referências válidas para operandos, valores e nomes de
comutadores.

Tabela 8.1 Tipos de referência do comutador

Item Referenciado Coloque em Definição de Exemplo
Operando Citações de volta (``) `ResName` ==” Machine ”
Valor do operando Aspas duplas (" ") "Estado" <> "Ocupado"
Interruptor - Switch1 &&! Switch2
Para definir a expressão condicional para uma definição de comutador, você pode usar
um ou mais operadores de comparação lógica ou matemática padrão, resumidos na
Tabela 8.2.
Os operadores são listados na ordem de avaliação de uma condição do comutador.

Tabela 8.2 Operadores lógicos de definição de switch

Lógico
Operador Significado Usar Exemplo
== "é igual a" Compare op ao valor `Configuração
necessária` ==”
Sim ”
<> "Não é igual a" Compare op ao valor Contador` <> "Nenhum"
! "não" Tome o oposto de um !SwSetupRequired
valor de comutador
&& "e" Combine comparações, SwCount &&
exigindo que ambas `Contador` ==”
sejam verdadeiras Individual ”
|| "ou" Combine comparações, SwSetup ||
exigindo que elas sejam SwNewRecipe
verdadeiras
> "é melhor que" Compare op ao valor "Número"> "14"
>= "é maior que ou Compare op ao valor "Peso"> = "100,3"
igual a"
< "é menos do que" Compare op ao valor `Time` <" 10,5 "
<= "É menor ou igual a" Compare op ao valor `Tabelas` <=” 20 ”

As comparações de operandos com valores são realizadas comparando os caracteres

digitados para o valor do operando com os caracteres especificados entre aspas
duplas na definição da opção. Essas comparações não diferenciam maiúsculas de
minúsculas.
Parênteses não são suportados nas definições de opção. Para condições complexas,
separe a condição para que as comparações agrupadas (ou seja, aquelas que você
gostaria de colocar entre parênteses) sejam definidas em comutadores individuais e,
em seguida, use esses comutadores para criar a condição maior e complexa.
Conforme descrito em “A Janela Modelo”, você pode visualizar uma lista das opções
definidas para todos os módulos em um arquivo de painel de modelo ou para um
único módulo usando a opção de menu Verificar> Relatório. Este relatório lista uma
tabela de nomes e definições de comutador, para que
 você pode visualizar um resumo de todas as definições de switch juntos, em vez de
precisar editar cada switch individualmente.
Os comutadores são exibidos na janela do comutador em ordem alfabética.

Regras de definição de switch

 Uma opção não pode se referir a si mesma em sua definição.
 Referências circulares não são permitidas. Isso significa que um comutador não
pode fazer referência a outro comutador que usa o primeiro comutador em sua
definição. Por exemplo, se o comutador SwBind estiver definido como
SwLooseleaf && `Format` ==” 3 Ring ”, o comutador SwLooseleaf não
poderá conter uma referência ao SwBind.
 Um comutador não pode ser anexado a um operando que é referenciado em sua
definição. Por exemplo, o comutador SwBind definido acima não pode ser
anexado ao operando Format, pois Format é usado em sua definição.
Isso se aplica a referências diretas (como no operando Format no exemplo
acima) ou a referências indiretas criadas usando opções contidas em uma
definição. Por exemplo, se o comutador SwLooseleaf no exemplo acima tiver
sido definido usando a condição `Prebound` ==” No ”, o comutador SwBind não
poderá ser conectado ao operando Prebound, pois o Prebound está envolvido na
definição do SwBind indiretamente através do SwLooseleaf.
 Se um comutador referenciar um operando repetível, o comutador terá um valor
separado para cada tupla (ou seja, cada conjunto de valores para os operandos
de repetição) do grupo de repetição do módulo. (Consulte o capítulo “A janela
Design de diálogo” para uma discussão sobre grupos e tuplas repetidos.)
Por exemplo, o módulo Atribuir do painel Processo básico permite atribuições
repetidas para diferentes tipos de elementos, como Atributos, Variáveis ou
Imagens. O grupo de repetição de atribuição contém um conjunto de operandos
com comutadores que garantem que apenas o operando apropriado seja
exibido, com base na seleção do tipo de atribuição. Uma opção é verdadeira
quando Atributos é selecionado, uma é verdadeira quando Variável é
selecionada e assim por diante
Quando o módulo Atribuir é usado em um modelo, a primeira tupla pode atribuir
um atributo; o segundo, uma foto; e o terceiro, uma variável. Os comutadores do
módulo são avaliados para cada tupla individual. No caso da primeira tupla, a
opção verdadeira quando Atributos é selecionado tem um valor verdadeiro, mas
as opções baseadas no tipo de atribuição que são Variáveis, Imagens etc. são
falsas. No
 segunda tupla, a opção Imagens é verdadeira e as demais são falsas. E na
terceira tupla, a opção Variáveis é verdadeira.
 Como o valor do comutador muda dependendo do conjunto de operandos
repetidos (ou seja, tupla) que você está examinando, um comutador que faça
referência a um operando repetível deve ser anexado apenas aos operandos no
mesmo grupo de repetição.
 Um comutador não pode fazer referência a um grupo de repetição inteiro
(ou seja, comutadores apenas podem referenciar operandos).
 Uma opção não pode se referir a uma tupla específica do grupo de repetição (por
exemplo, a quinta atribuição em um módulo).

180
9 A janela de ícone do painel
O ícone do painel de um módulo é a exibição gráfica que aparece em um painel quando
um modelador anexa um painel de modelo à barra de projetos. A Figura 9.1 mostra
o painel que é exibido quando o painel Processo básico do modelo Arena é anexado.

Figura 9.1 Painel Processo básico do modelo Arena

Os ícones do painel são definidos em uma janela de ícone do painel usando objetos de
desenho como linhas, caixas ou círculos. Para abrir a janela de ícone do painel de um
módulo, selecione o módulo na lista Definições do módulo da janela do modelo e
escolha o item de menu Janela> Ícone do painel ou clique no botão Editor de ícones
do painel na barra de ferramentas Desenvolvimento de modelos.
ARENA TEMPLATE DEVELOPER’S GUIDE

Uma janela de ícone do painel é mostrada na Figura 9.2.

Figura 9.2 Janela do ícone do painel

Criando o ícone do painel

Existem três opções de exibição de painel permitidas para modelos: Botões padrão
(o padrão), Botões grandes e Somente texto. Essa configuração é definida na caixa
de diálogo Opções de modelo (consulte o capítulo "A janela de modelo"). Todos
os ícones em um arquivo de painel de modelo são do mesmo tamanho.
Para projetar seu ícone, recomendamos que você selecione uma imagem muito
simples que represente a atividade do módulo e rotule-a colocando o nome do
módulo na parte inferior do ícone. Quando você abre a janela do ícone do painel, o
Arena coloca automaticamente o nome do módulo (apenas as quatro primeiras
letras) como um objeto de texto na parte inferior da janela do ícone do painel.
Você pode alterar as características desse objeto como faria ao editar qualquer
outro objeto de texto (por exemplo, alterar a sequência de caracteres, o tamanho e a
orientação) clicando duas vezes no texto padrão.
Você pode usar a barra de ferramentas Desenhar para criar gráficos adicionais para o
seu ícone, selecionando as ferramentas desejadas na paleta e colocando objetos na
janela. As características dos objetos (largura e estilo da linha, borda e cores de
preenchimento) podem ser especificadas antes ou depois da colocação dos objetos na
janela. Os objetos de desenho também podem ser colados a partir de outra janela
usando a área de transferência.
Você também pode acessar a Arena Symbol Factory para recortar e colar símbolos
na janela de ícone do painel. Para acessar esta biblioteca de símbolos, vá em
Ferramentas> Arena Symbol Factory. Selecione uma categoria de símbolos e clique
no símbolo que você precisa. Isso colocará o símbolo na caixa Visualizar, onde você
poderá copiá-lo para a área de transferência e colá-lo na janela de ícone do painel.
182
10 Elementos
Em muitos casos, os módulos que construímos representam um componente de um
sistema que contém um ou mais objetos. Por exemplo, podemos construir um
módulo de estação de trabalho que represente um buffer de entrada, um trabalhador,
uma máquina e um buffer de saída. Esses objetos no sistema têm certas
características e comportamentos que devemos capturar em nosso módulo. Por
exemplo, o buffer interno deve manter um conjunto ordenado de peças a serem
processadas na máquina.
O Arena, através de sua linguagem básica SIMAN, fornece um conjunto completo de
objetos de modelagem chamados elementos que podem ser usados diretamente para
representar os componentes de um sistema. Por exemplo, o Arena fornece um
elemento da fila que mantém uma lista ordenada de itens e possui operações para
inserir e remover entidades da fila e para pesquisar e classificar os membros da fila.
Ao usar os elementos internos do Arena em seus módulos, você obtém acesso a
objetos de modelagem predefinidos que representam componentes físicos complexos
em seu sistema. Os elementos são importantes na construção do módulo, pois
fornecem um mecanismo poderoso para representar objetos padrão em um módulo,
como trabalhadores, equipamentos, transportadores ou carrinhos.
Embora os elementos mencionados em um módulo sejam freqüentemente usados
para representar componentes físicos de sistemas, como máquinas e trabalhadores,
em alguns casos, os elementos são usados para representar informações como
planos de processo, padrões de falha ou agendamentos de turnos. Esses elementos
de dados fornecem um método estruturado para representar informações do sistema.
O Arena fornece operações que acessam os dados contidos nesses elementos com
base no tipo de elemento. Por exemplo, uma entidade pode passar por uma operação
de rota que faz referência a um elemento de sequência; nesse caso, o elemento de
sequência especifica a estação de destino e as atribuições a serem feitas aos
atributos da entidade e variáveis de modelo.
O poder real dos elementos está na funcionalidade interna fornecida automaticamente
pelo Arena e pelo SIMAN para cada tipo de elemento. Quando você incorpora um
elemento em seu módulo, ele possui um conjunto padrão de características,
chamadas propriedades, que descrevem o elemento e um conjunto padrão de
operações que podem ser aplicadas para alterar seu estado. Por exemplo, se você
emprega um elemento de recurso, ele possui um conjunto padrão de propriedades de
dados que o descrevem (padrão de capacidade ou turno, estados operacionais,
características de falha e reparo etc.), além de operações padrão que podem alterar
seu estado ( como Apreender, Liberar ou Preemptar). Da mesma forma, um elemento
transportador possui propriedades padrão que especificam suas características (como
caminho ou velocidade) e operações padrão que alteram seu estado (como Parar,
Iniciar ou Transportar).
 10 • ELEMENTS

Embora existam alguns tipos de elementos principais que são comumente usados na
construção de módulos, há um total de mais de 40 tipos diferentes de elementos
integrados na linguagem SIMAN para representar a grande variedade de
componentes do sistema que você pode encontrar. O conjunto completo de tipos de
elementos e suas propriedades e operações correspondentes estão documentados em
detalhes na ajuda online. A Tabela 10.1 lista algumas das propriedades e operações
associadas a seis elementos usados com freqüência.

Tabela 10.1 Alguns elementos e propriedades e operações de amostra

Elemento Propriedades Operações
Recurso Nome Apreend
Capacidade ou Horário er
Padrão de falha de estados Liberaç
(ocupado, ocioso e assim por ão
diante) Preempt
Custeio e Eficiência Alter
Transportador Nome Acesso
Velocidade Iniciar
dos segmentos Saída
de caminho Sair
Tipo de
status do
tamanho
Transportador Nome Alocar
Número de Solicitaçã
unidades Tipo o de
Desaceleraç Movimen
ão da tação de
aceleração Transport
de e
velocidade Gratuito
Características iniciais da Ativar
Fila Nome Pesquis
Indicador a de
Compartilhado de inserção
Critério de de fila
Classificação Remove
Estação Nome Estação
Receita de interseção de
associada transporte
de rota de
transporte

184
 Tabela 10.1 Alguns elementos e propriedades e operações de amostra
Elemento Propriedades Operações
Variável Nome Atribuir
Valor inicial

O Arena fornece um conjunto completo de módulos para manipular o estado de um

elemento. O modelo Arena fornece módulos para referenciar e usar os tipos de
elementos mais comuns, como estações, recursos, transportadores e
transportadores. Os módulos no painel Processo básico fornecem acesso a esses
elementos no nível da estação de trabalho ou do componente da estação de
trabalho. Por exemplo, o módulo Process representa uma operação na qual vários
recursos podem ser capturados, mantidos por um tempo especificado e depois
liberados.
O painel Processo Avançado fornece operações de nível inferior a partir das quais
operações complexas podem ser construídas. Por exemplo, o módulo Capturar no
painel Processo avançado permite capturar unidades de um ou mais recursos, e o
módulo Liberar permite liberar um ou mais recursos. Ao combinar esses módulos
com outros módulos, é possível representar uma lógica de recursos muito complexa.
Os módulos no painel Transferência avançada fornecem acesso aos elementos
usados para representar dispositivos de transferência de material, como
transportadores, carrinhos ou AGVs.
Em alguns casos, pode ser necessário acessar operações adicionais (por exemplo,
varrendo uma condição) que não são diretamente suportadas pelo modelo Arena ou
você pode precisar usar um ou mais elementos que não têm suporte direto no
modelo Arena. Nesse caso, você pode usar os módulos do modelo SIMAN para
definir e manipular esses elementos. Os elementos no SIMAN são definidos usando
os módulos no painel Elementos; as operações para manipular esses elementos são
fornecidas nos módulos incluídos no painel Blocos. Os módulos nos painéis
Elementos e blocos fornecem acesso completo a todos os tipos e operações de
elementos suportados pelo idioma SIMAN.

Definindo elementos em módulos

Criando elementos
Ao definir um módulo, você pode especificar que um ou mais elementos, como
filas, recursos ou transportadores, sejam criados quando um modelador coloca uma
instância do seu módulo. Seu módulo também pode apresentar propriedades de seus
elementos na caixa de diálogo do módulo para que um modelador possa alterar as
características dos elementos. E a
A lógica do módulo pode especificar operações que atuam nos elementos do
módulo, como apreender um recurso ou transportar para uma estação de destino.
Em uma definição de módulo, você pode criar um elemento de duas maneiras.
Primeiro, na janela lógica do seu módulo, você pode colocar instâncias de módulos
que eles mesmos criam elementos. Por exemplo, se você estiver definindo um
módulo de linha de cozimento e colocar uma instância de Processo na janela lógica
que especifica um recurso chamado Oven, um elemento de recurso do Oven será
criado quando um modelador usar seu módulo de linha de cozimento. Você pode
pensar nesse mecanismo como elementos definidores na hierarquia da Arena.
O segundo mecanismo para criar elementos é colocar um operando na janela de
design da caixa de diálogo da definição do módulo e, na propriedade LogicProperties
do operando, especifique o operando como um Elemento. Nesse caso, você não
precisa colocar uma instância do módulo na janela lógica para fazer com que o
elemento seja criado. Em vez disso, especificando que o tipo do operando é Element,
você indica que o valor desse operando em uma instância do seu módulo deve ser
usado como o nome de um elemento. Você pode pensar nessa abordagem como
definindo elementos de operandos de elementos. Consulte “A Janela Design do
Diálogo” para obter uma descrição da propriedade LogicProperties e dos tipos de
operando.
As duas abordagens para definir elementos, incluindo seus méritos, serão discutidas
mais adiante“Definindo elementos da hierarquia” na página 190 e "Operandos do
elemento" na página 190.

Listas de elementos
Quando um modelador cria um elemento (por exemplo, um recurso), ele é
adicionado a uma lista que é armazenada como parte do modelo de simulação. Essas
listas de elementos são armazenadas separadamente por tipo de elemento. As
instâncias do módulo podem exibir essas listas para que, em muitos casos, um
modelador possa selecionar um elemento existente em uma lista.
Por exemplo, se você criar um modelo contendo os módulos Enter, Process e Leave
a partir do modelo Arena, poderá definir o nome da estação no módulo Enter como
Trabalhos de Impressão. Quando você faz isso, um elemento da estação chamado
Trabalhos de impressão é adicionado ao modelo de simulação e à lista de elementos
da estação. No módulo Processo, você pode especificar que as entidades requeiram
processamento com um recurso chamado Joe, adicionando um elemento à lista de
recursos. Ao editar o módulo Sair, se você precisar de um recurso para transferir o
módulo usando uma transferência de estação, encontrará o recurso Joe e os
Trabalhos de impressão da estação já nas listas de recursos e estações,
respectivamente.
O uso de listas de elementos nas definições de módulo pode tornar um modelo muito
mais fácil para os modeladores, permitindo que eles selecionem os elementos que já
definiram em seu modelo, em vez de precisar digitar novamente o nome do elemento.
Você pode ainda
 adapte as listas apresentadas a um modelador usando sublistas de elementos.
Este conceito é descrito em“Operandos do elemento” na página 190.

Propriedades
Os elementos têm características que chamamos de propriedades. Um elemento
específico que foi criado em um modelo de simulação, como um recurso chamado
Oven, possui seu próprio conjunto de valores para suas propriedades. Um elemento
de recurso (por exemplo, Oven) pode ter capacidade para 12, enquanto outro
elemento de recurso (por exemplo, Bake Prep) pode ter capacidade para 1.
Você pode permitir que um modelador defina os valores da propriedade para um
elemento específico usando um dos dois mecanismos na definição do módulo que são
semelhantes aos disponíveis para a criação de elementos. No primeiro caso, você
coloca uma instância do módulo (como um módulo Recurso do painel Elementos) na
janela lógica da sua definição de módulo. Nesta instância do módulo, você pode
especificar que as propriedades do elemento sejam definidas por meio de referências
aos operandos do módulo (por exemplo, um operando de capacidade do recurso).
Nesse caso, seu módulo atribui um valor à propriedade através da hierarquia.
O segundo mecanismo para definir uma propriedade é colocar um operando na janela
de design da caixa de diálogo da definição do módulo e, na propriedade
LogicProperties do operando, especifique o operando como uma Propriedade. Em
seguida, você especifica qual operando na definição do módulo define o elemento ao
qual o operando da propriedade deve ser associado (por exemplo, o operando que
define o recurso, se a propriedade for uma capacidade do recurso). Essa abordagem
tem o benefício de exibir corretamente a propriedade de um elemento, mesmo que
seja definida por mais de uma instância de módulo em um modelo de simulação.
Discutimos mais essa abordagem em“Definindo Operandos de Propriedade” em
página 194.

Uso de elementos e propriedades nas

definições de módulo
O conceito de elementos e propriedades é importante em relação ao design do
modelo por dois motivos principais. Primeiro, o armazenamento de elementos e
propriedades da Arena como informações globais permite o acesso às propriedades
de um elemento específico por muitas instâncias de módulo em um modelo de
simulação. Segundo, os elementos podem ser coletados em listas para apresentação
nas caixas de diálogo do módulo. Discutimos esses dois conceitos nas seções a
seguir.
Acesso às propriedades em um modelo
O uso de operandos de elemento e propriedade permite que os modeladores acessem
informações relacionadas a elementos em mais de um local em um modelo de
simulação. Embora as informações de propriedade de um determinado elemento
sejam globais e possam ser acessadas por vários módulos, é recomendável que as
informações de propriedade de um elemento sejam definidas em um único módulo,
como um módulo de dados, para um determinado tipo de elemento. Isso normalmente
elimina a confusão do usuário final, de modo que as propriedades de um recurso,
como capacidade, cronograma ou falhas, são definidas e alteradas em apenas um
local, não em vários módulos. O recurso Módulo criado automaticamente permite que
módulos do tipo lógico definam módulos de dados automaticamente. Consulte a
descrição da propriedade LogicProperties do objeto operando no capítulo "A janela
de design do diálogo".
Por exemplo, se você estava construindo um modelo de uma linha de soldagem, pode
usar um módulo Processo (no painel Processo Básico) para representar o processo de
soldagem de peças do tipo padrão. Outro conjunto de lógicas no mesmo modelo para
soldar peças superdimensionadas pode usar um módulo de processo diferente. Ambos
os módulos usariam o recurso de soldagem para processamento. Um módulo de dados
do recurso (também no painel Processo básico) é criado automaticamente para o
recurso de soldagem, com informações padrão para suas propriedades, como uma
capacidade de 1. O módulo de recursos pode ser editado para especificar as
características do recurso de soldagem ( por exemplo, seus padrões de agendamento
ou falha).
Embora você possa definir um módulo que contém informações de propriedades na
caixa de diálogo, como definir um tipo de processo do módulo em que o usuário
possa definir informações sobre capacidade e agendamento no próprio módulo de
processos, você é limitado pela terminologia associada ao SIMAN ao especificar
propriedades informações, como os operandos são operandos do tipo de
propriedade e devem alimentar diretamente um campo do elemento SIMAN para
serem globais. Por exemplo, se você solicitar a um usuário em uma caixa de diálogo
a regra de agendamento para um agendamento de recursos, especifique as palavras-
chave Esperar / Ignorar / Preemptar se o campo for um operando do tipo de
propriedade em um módulo que pode ser colocado várias vezes (como como um
módulo do tipo Process). Se um alias for usado (consulte “A Janela de Design do
Diálogo” para obter informações sobre o uso de aliases), o campo não poderá mais
ser um operando de propriedade acessível a partir de vários módulos.

Exibindo listas de elementos

O uso de elementos também oferece a vantagem de exibir listas para modeladores
(como descrito anteriormente). Essas listas são classificadas por tipo de elemento
(por exemplo, recursos, filas ou estações) para que um modelador seja apresentado
com uma lista de elementos restritos ao tipo apropriado com base no uso do
operando no módulo. Por exemplo, se você adicionar um controle ComboBox ao
design da caixa de diálogo de um módulo e
depois defina esse operando como um operando de elemento, a lista suspensa do
operando exibirá todos os elementos que foram adicionados ao modelo (do tipo
de elemento definido pelo operando).
Um operando básico ou de propriedade que é um controle ComboBox também pode
apresentar uma lista de elementos. (Consulte “A Janela Design de Diálogo” para
obter descrições dos controles da interface do usuário que podem ser adicionados às
caixas de diálogo do módulo.) Nesse caso, a lista suspensa exibe os elementos que
foram criados no modelo para que um modelador possa selecionar a partir desses
elementos já definidos. No entanto, se uma nova entrada for feita em um operando
básico ou de propriedade, esse novo valor não será adicionado à lista de elementos.
Por exemplo, no módulo Corresponder no painel de blocos do SIMAN, o campo
Expressão de correspondência exibe uma lista de atributos. No entanto, se um
modelador digitar um valor, como PalletSize, no campo Quantidade que não
corresponde aos atributos que já foram definidos, um novo elemento de atributo não
será criado. Isso ocorre porque o campo Corresponder Expressão realmente aceita
qualquer tipo de valor de expressão; no entanto, é comum usar um atributo para esse
campo.
A exibição de listas de elementos em operandos que não são elementos geralmente
é útil quando o tipo de dados do operando é expressão (para permitir operadores
matemáticos, etc.), mas onde um tipo de elemento específico geralmente é usado.
Nos guias de referência do modelo, listamos o tipo de elemento entre parênteses, se
a lista for apenas para exibição ou entre colchetes, se o operando definir um
elemento.
Como designer de modelo, você pode criar sublistas para restringir ainda mais o
escopo da lista de elementos fornecida a um modelador. Por exemplo, se você tiver
um operando que defina um recurso, poderá identificar uma sublist associada a esse
operando; por exemplo, operadores. Quando um modelador define um novo
elemento digitando um nome no campo de recurso, o elemento é adicionado à sub-
lista Operadores. Outros módulos em seu modelo ou em outros modelos também
podem exibir a sub-lista Operadores de elementos de recurso. Nesse caso, o
modelador é apresentado com uma lista apenas dos elementos de recursos que foram
especificados como Operadores. Outras sublistas de recursos, como Supervisores,
Máquinas CNC e Operadores de Configuração, podem existir para coletar
classificações adicionais de elementos de recursos.
As informações sublistas em “Operandos do elemento” na página 190fornece
informações adicionais sobre listas de elementos. Essas listas podem resultar na
criação de modelos muito mais rápida para um modelador, além de diminuir a
probabilidade de o modelador inserir informações incorretas.
 Definindo elementos da hierarquia
Em uma definição de módulo, a maneira mais direta de projetar o módulo para que
ele crie os elementos necessários quando é usado em um modelo é através da
hierarquia. Se você estiver definindo um módulo e colocar instâncias dos módulos
Enter, Process e Leave em sua janela lógica, por exemplo, vários elementos serão
criados automaticamente em qualquer instância do seu módulo, como recursos,
estações ou dispositivos de manuseio de material que você especificar. Usando essa
abordagem, você não precisa se preocupar em adicionar informações à sua definição
de módulo em relação aos elementos. (Os elementos foram definidos
automaticamente pelas instâncias do módulo.) De fato, ao longo deste guia,
fornecemos exemplos de módulos sem discutir o conceito de elementos.
Para definições simples de módulos, essa abordagem será suficiente. As informações
apropriadas serão fornecidas para definir completamente o modelo de simulação (ou
seja, a lógica e os elementos). No entanto, apenas definir elementos através da
hierarquia não fornece os benefícios listados na seção anterior (ou seja, definir listas
de elementos ou acessar propriedades).
Nota: Se você exibir qualquer propriedade de elemento na caixa de diálogo do
módulo, é altamente recomendável usar operandos de elemento e propriedade no
design da caixa de diálogo, em vez de hierarquia, para definir os elementos.

O restante deste capítulo (com exceção da seção "Switches e elementos") se

refere ao uso de operandos de elemento e propriedade nas definições de módulo.

Operandos do elemento
Definindo Operandos do Elemento
Conforme descrito na introdução, no design da caixa de diálogo da definição do
módulo, um operando pode ser identificado como um tipo de elemento, o que indica
que o valor do operando em uma instância do módulo será usado para nomear um
elemento.
Na janela de design da caixa de diálogo, todos os objetos de operando têm uma
propriedade LogicProperties disponível na grade Propriedades da janela. Essa
propriedade fornece uma caixa de diálogo para especificar características do operando
relacionadas à sua finalidade na interface e na lógica do módulo.
Na caixa de diálogo Propriedades da lógica, o Tipo do operando pode ser especificado
como Elemento.

190
Figura 10.1 Caixa de diálogo Logic Properties para um operando Element

Quando o Tipo é especificado como Elemento, os seguintes campos são exibidos:

Tipo de elemento- O tipo de elemento SIMAN que o operando definirá ou fará
referência. Selecione o tipo desejado da lista. O valor do operando será usado como
o nome do elemento do tipo selecionado (por exemplo, um operando com o valor
Operator definirá ou fará referência a um elemento SIMAN com o nome Operator).
Sublist- A partição da sublista de elementos (por Tipo de elemento, como recurso)
dos quais o elemento deste operando deve ser um membro. Por exemplo, o tipo de
elemento Resources pode ter sublistas para Operadores e Máquinas. As sublistas são
descritas em mais detalhes na próxima seção.
Definir / Referência- Indica se o elemento criado por esse operando deve ser definido
para o modelo de simulação ou se deve ser referenciado apenas. Se Referência for
selecionado, algum outro módulo deverá definir o elemento que é referenciado por
este módulo. Normalmente, isso é usado quando informações de propriedade
incompletas são definíveis em um módulo.
Sublistas
As sublistas permitem particionar em subconjuntos as listas de elementos que são
apresentadas a um modelador. Há uma sub-lista padrão para cada tipo de elemento
com o mesmo nome do elemento (por exemplo, RECURSOS). Elementos criados
por instâncias de módulos dos modelos Arena e SIMAN são adicionados a esta
sublist.
Nota: Se o campo sublist estiver em branco na definição de operando, qualquer
elemento criado por uma instância do módulo será adicionado à lista principal de
elementos, que apresenta uma lista de todos os elementos do tipo de elemento
específico (ou seja, a combinação de todos os elementos definidos como membros
de todas as sublistas).

Na Figura 10.1, a sub-lista na caixa de diálogo Logic Properties do operando é

especificada como "Inserters". Assim, cada vez que um valor é inserido nesse
operando em uma instância do módulo, um novo elemento (ou seja, um recurso)
será criado e adicionado à sub-lista de elementos do recurso Inserters.
Usando sublistas no design do seu modelo, você pode apresentar os vários elementos
representados no seu modelo em quantos grupos ou classificações diferentes desejar.
Cada classificação (ou seja, sublist) é um nome associado a uma lista de elementos
específica.
Por exemplo, um modelo que contém um módulo de Inserção automática com o
operando na Figura 10.1 também pode ter um módulo para operações de solda que
define os recursos de solda. Sublists podem ser criadas para colocar os elementos de
recurso Inserção automática em uma sublist de inserção e os elementos de recurso
de operação de solda em uma sublist de solda. Quando um modelador deseja
selecionar um recurso de Inserção automática para executar uma operação, a lista
suspensa apresentada na caixa de diálogo apresentaria apenas os elementos de
recurso que foram definidos para serem inseridores (ou seja, foram colocados na
sub-lista de inserdores) . Os recursos de solda não seriam exibidos na lista suspensa
de insersores.
Nota: Em qualquer modelo, as sublistas são compartilhadas entre módulos de
diferentes arquivos do painel de modelos. Por exemplo, se um módulo de um
modelo adicionar um elemento à sub-lista de recursos Inserters, outro módulo de
um modelo diferente também poderá adicionar elementos à mesma sub-lista.

Na janela de design da caixa de diálogo, se um controle ComboBox for

especificado como um operando básico ou de propriedade, a propriedade List do
controle também poderá ser especificada para mostrar um tipo de elemento e uma
sublista. Esses recursos funcionam de maneira idêntica à descrição das entradas
na Figura 10.1.

192
Definindo e referenciando elementos
Se você adicionar um operando de elemento a um módulo, poderá especificar se
os elementos criados pelo operando devem ser colocados no modelo de simulação
e adicionados às listas de elementos ou se o elemento deve ser adicionado apenas à
lista de elementos. Isso é controlado pela opção Definir / Referência na caixa de
diálogo da propriedade LogicProperties do objeto operando (veja a Figura 10.1).
Se você selecionar Definir, o elemento será adicionado ao modelo de simulação (ou
seja, será gravado no arquivo experimental do SIMAN) e seu nome será adicionado
à lista de elementos apropriada (na sub-lista especificada). Se você indicar que o
operando é apenas uma referência a um elemento, o nome do elemento será
adicionado apenas à lista de elementos. Nesse caso, o elemento ainda não está
definido para fazer parte do modelo de simulação; isto é, ele não será gravado no
arquivo experimental do SIMAN até que outra instância do módulo contendo um
operando do elemento Define do tipo com o mesmo valor seja colocada.
Esse tipo de operando de elemento, um operando de referência, é usado quando um
módulo contém um operando que especifica um elemento, mas o módulo não contém
o conjunto completo de operandos para definir as propriedades necessárias do
elemento. Se um elemento for criado em um modelo de simulação apenas por meio
de operandos do elemento de referência, um erro de Identificador Indefinido será
fornecido se o modelo for verificado.
O uso do botão Configurações do módulo criado automaticamente na caixa de
diálogo da propriedade LogicProperties de um operando permite mais flexibilidade
na definição e referência de um elemento. Um módulo de dados, por exemplo, pode
ser criado automaticamente usando o recurso Módulo criado automaticamente
quando um elemento específico é referenciado. Consulte "A janela Design do
diálogo" para obter mais detalhes.
Por exemplo, o módulo Licença do painel Transferência avançada contém um
campo nomeando o transportador a ser solicitado se você selecionar Solicitar
transportador como o mecanismo de transferência. Se você inserir um nome de
transportador, como Shuttle1, um elemento chamado Shuttle1 será adicionado à lista
de transportadores. Isso criará automaticamente uma entrada do módulo de dados
Transporter com o nome Shuttle1, contendo informações padrão sobre o
transportador, incluindo um nome de conjunto de distância Shuttle1.Distance. No
entanto, como propriedades necessárias, como o conjunto de distâncias do
transportador, não fazem parte do módulo Licença ou Transportador, um modelador
que apenas coloca o módulo Licença não definiu completamente as informações do
transportador. Nesse modelo, o elemento transportador Shuttle1 possui um indicador
de que é apenas referenciado (ou seja, ainda não definido). Para ter um modelo
completo, o modelador precisaria editar o módulo de dados que define o conjunto de
distância Shuttle1.Distance. Tentar executar o modelo sem fazer isso exibirá uma
janela de Erro, especificando “Este módulo não foi editado”, onde você pode clicar
no botão Localizar que o levará ao módulo de dados Distância.
Operandos de propriedade
Definindo operandos de propriedades
Na janela de design da caixa de diálogo de uma definição de módulo, na
propriedade LogicProperties de um objeto operando, o Tipo do operando também
pode ser especificado como Propriedade.

Figura 10.2 Caixa de diálogo Logic Properties para o operando Property

Quando o Tipo é especificado como Propriedade, os seguintes campos são exibidos na

caixa de diálogo Propriedades da Lógica:
Operando de elemento- Nome do operando que está definindo o elemento SIMAN
neste módulo ao qual esse operando de propriedade está associado. Na Figura 10.2,
um operando de elemento denominado Inserter ID foi adicionado ao design da caixa
de diálogo. Este operando está definindo um elemento RESOURCES. Agora
estamos definindo um operando de propriedade apontando para uma propriedade
desse recurso.
Tipo de elemento- Tipo de elemento SIMAN definido ou referenciado pelo
operando do elemento. Este campo não pode ser editado; é fornecido apenas
para informação.
Nome da propriedade- Nome da propriedade do elemento para a qual esse operando
está apontando, selecionado em uma lista de propriedades válidas associadas ao
Tipo de elemento. (Veja as tabelas no Apêndice B para obter uma lista dos tipos de
propriedades que são definidos para cada tipo de elemento.) No exemplo da Figura
10.2, selecionamos a propriedade "Número inteiro ou ID do agendamento", que
define o valor da capacidade (inteiro) para um recurso de capacidade fixa ou o nome
do planejamento para um recurso cujo tipo de capacidade é Planejamento.
Somente leitura- Essa opção estará disponível apenas se o operando for um controle
HiddenOperand no design da caixa de diálogo. Se ativado, o operando oculto lerá em
seu valor o valor atual da propriedade do elemento ao qual está associado. O valor da
propriedade do elemento NÃO será substituído pela propriedade Value do operando.
O valor padrão definido para o operando oculto será gravado apenas no valor da
propriedade do elemento se essa propriedade ainda não tiver sido definida (ou seja, o
valor atual da propriedade é nulo).
O recurso Somente leitura pode ser usado para permitir que os módulos se
comuniquem indiretamente. Por exemplo, um módulo "mestre" pode definir uma
opção para "Coletar estatísticas", que seria gravada como uma propriedade de um
elemento nomeado. Todos os outros módulos "subordinados" poderiam ter
operandos ocultos referentes ao elemento nomeado e sua propriedade, mas os
operandos de propriedades ocultas nos módulos "subordinados" teriam a opção
Somente leitura marcada. Outros operandos que coletam vários tipos de estatísticas
nos módulos "subordinados" podem ser ativados ou desativados, dependendo do
valor do operando da propriedade oculta. Dessa forma, a edição do módulo "mestre"
afetaria os outros módulos, fornecendo a você um tipo de recurso "Operando
global".

Definindo propriedades repetidas

Alguns elementos contêm propriedades cujos valores são repetíveis, como
posições iniciais das unidades transportadoras definidas por um elemento
Transportadores ou a lista de falhas de um elemento Recurso.
No design da caixa de diálogo da definição do módulo, um objeto de grupo de
repetição (controle RepeatGroupDialog ou RepeatGroupTable) pode ser
especificado para ser um grupo de repetição de propriedade. Ao definir um grupo de
repetição de propriedades, você indica que um conjunto de valores repetidos será
gravado por um ou mais operandos de propriedades contidos no grupo de repetição.
Consulte o capítulo “A janela Design de diálogo” para obter mais informações sobre
o uso de grupos de repetição no design da caixa de diálogo do módulo.
Semelhante aos objetos operandos, a propriedade LogicProperties de um grupo de
repetição especifica se o grupo de repetição está apontando para a propriedade
repetível de um elemento. A Figura 10.3 mostra a caixa de diálogo Logic Properties
para um objeto de grupo de repetição de propriedade. Naquilo
Por exemplo, o grupo de repetição está apontando para a propriedade Failures de
um elemento RESOURCES (o recurso está sendo definido por um operando de
elemento Inserter ID).

Figura 10.3 Caixa de diálogo Logic Properties para um grupo de repetição de

propriedades

Se o Tipo do grupo de repetição for especificado como Propriedade, os seguintes

campos serão exibidos na caixa de diálogo Propriedades da Lógica:
Operando de elemento- Como é o caso na definição de operandos de propriedades,
esta entrada especifica o nome do operando que está definindo o elemento SIMAN
neste módulo ao qual esse grupo de repetição de propriedades está associado.
Tipo de elemento- O tipo de elemento SIMAN definido ou referenciado pelo
operando do elemento. Este campo não pode ser editado; é fornecido apenas para
informação.
Nome da propriedade- O nome da propriedade do elemento que este grupo de
repetição define, selecionado em uma lista de propriedades repetíveis válidas
associadas ao Tipo de elemento.
Nota: No design da caixa de diálogo, quando você define um grupo de repetição
como uma propriedade, todos os operandos e grupos de repetição que estão
contidos no grupo de repetição devem ser operandos de propriedade ou elemento.
Para ilustrar ainda mais o uso de grupos de repetição de propriedades, suponha que
tenhamos projetado um módulo de Inserção Automática com um design de caixa de
diálogo, como mostra a Figura 10.4 abaixo.

Figura 10.4 Visualização do Operand Explorer do design da caixa de diálogo

para o módulo de inserção automática

Primeiro, o módulo Inserção automática contém um objeto de grupo de repetição

denominado Falhas de inserção. Este grupo de repetição foi especificado como um
grupo de repetição de propriedades e aponta para a propriedade Failures de um
elemento de recurso definido pelo operando chamado “ID do Inserter” (consulte a
Figura 10.3).
No módulo Inserção automática, agora podemos definir uma ou mais falhas para o
recurso de inserção. Existem três operandos de propriedade no grupo de repetição de
falhas (consulte o apêndice de tabelas para esta lista): a palavra-chave Failure, o nome
da falha e a regra da entidade (Ignorar, Aguardar ou Preemptar).
Para a definição do módulo Inserção automática, adicionamos dois operandos de
propriedade ao grupo de repetição Falhas do inseridor. Primeiro, um operando de
palavra-chave de falha oculto é usado para fornecer a palavra-chave FAILURE
para uma entrada de falha. A caixa de diálogo da propriedade LogicProperties
para este operando é mostrada na Figura 10.5.
Figura 10.5 Caixa de diálogo Propriedades da lógica para o operando de palavra-
chave com falha oculto

Segundo, para o nome da falha, adicionamos um operando (Failure Class) ao grupo

de repetição e indicamos que é a propriedade Failure ID do recurso, como mostra a
Figura 10.6.

Figura 10.6 Caixa de diálogo Logic Properties para o operando da propriedade Failure
Class
Podemos escolher se deseja adicionar um terceiro operando de propriedade ao
módulo que especifica a regra da entidade com falha. Neste exemplo, não faremos
isso; nesse caso, a propriedade do recurso recebe o valor padrão, Ignorar.

Definindo um elemento ou propriedade usando um

operando oculto
No exemplo de Inserção automática, o operando Classe de falha identifica o nome
de uma falha que é propriedade de um recurso. No entanto, ele não cria o elemento
de falha nem define nenhuma das propriedades da falha (ou seja, o tipo de falha, sua
duração e assim por diante).
Podemos alterar o módulo para que ele defina o elemento de recurso do robô e defina
completamente os elementos de falha associados. A Figura 10.7 mostra um design
atualizado da caixa de diálogo para o módulo.

Figura 10.7 Visualização do Operand Explorer do design da caixa de diálogo

para o módulo de inserção automática aprimorado

Primeiro, precisaremos adicionar um operando de elemento que defina o

elemento de falha. Também precisaremos adicionar os operandos de propriedade
para as informações do elemento de falha.
Para definir o elemento de falha, adicionamos um operando oculto ao grupo de
repetição Falhas do inseridor. Este operando de elemento define um elemento do
tipo Falhas. Usamos uma referência de operando (`Failure Class`) para fornecer o
valor padrão desse elemento operando. Isso garante que o elemento de falha criado
seja nomeado corretamente com base na propriedade de falha do recurso.
 A Figura 10.8 mostra as propriedades de design do operando oculto
chamado “Failure_Element”.

Figura 10.8 Propriedades de design do operando do elemento oculto para definir o

elemento Failures

Apresentando o operando da propriedade na caixa de diálogo do módulo, garantimos

que, se outra instância do módulo alterar as falhas associadas a um recurso de
inserção automática, a instância do módulo de Inserção Automática será atualizada
para refletir os valores alterados. (Isso ocorre porque os valores das propriedades são
armazenados globalmente no modelo de simulação, conforme descrito
anteriormente.) O operando escondido Failure_Element assegura que o elemento de
falha também seja definido no modelo de simulação e fornece um operando de
elemento que as propriedades da falha podem fazer referência.
Neste exemplo, definiremos as informações de falha para a falha especificada no
módulo Inserção automática. Nesse caso, usamos Definir (em vez de Referência)

200
para o elemento Failure (como visto acima na Figura 10.8). Se o módulo de
inserção automática especificasse o nome da falha e um módulo de dados de falhas
separado definisse as características da falha, esse módulo ainda conteria o
operando oculto acima (para que o nome da falha esteja na lista de falhas); no
entanto, o elemento teria uma referência a ele, em vez de defini-lo.
Para definir as propriedades da falha, três operandos de propriedade adicionais são
adicionados ao grupo de repetição Falhas do inseridor, correspondendo às três
propriedades necessárias de um elemento de falha: Tipo de falha, Tempo ou
Contagem entre e Duração. A Figura 10.9 mostra a caixa de diálogo do operando
para o primeiro deles, o Tipo de falha. Em sua definição, ele é especificado para ser
um tipo de propriedade de operando; é uma propriedade do elemento nomeado pelo
operando Failure_Element; e é a propriedade Type do elemento de falha. Os dois
operandos restantes (Contagem ou Tempo entre e Tempo para reparar) são definidos
da mesma forma, com a seleção apropriada do tipo de propriedade (Tempo ou
Contagem entre e Duração, respectivamente).

Figura 10.9 Caixa de diálogo Propriedades da lógica do operando da propriedade Tipo

de falha
 Na Figura 10.10, mostramos uma instância de amostra do módulo de Inserção
automática. Esta instância define um recurso de inserção chamado DIP_Line A,
seguindo o agendamento de dois turnos. O recurso possui duas falhas associadas:
Fora de tolerância (cuja caixa de diálogo de grupo de repetição é aberta na figura) e
Manutenção preventiva.

Figura 10.10 Exemplo de exemplo de inserção automática

Interruptores e elementos
Os comutadores podem ser anexados aos operandos do elemento no design da caixa
de diálogo, especificando a propriedade SwitchName nas propriedades de design do
objeto. Ou então, você pode selecionar o objeto e usar o item de menu Objeto>
Alternar> Anexar para anexar uma opção e selecionar a opção na lista apresentada na
caixa de diálogo Anexar opção. Consulte o capítulo "A janela de design da caixa de
diálogo" para obter mais informações.
Quando um módulo que inclui operandos de elemento com comutadores é usado em
um modelo de simulação, o comportamento dos comutadores relacionados à
aparência da caixa de diálogo do módulo também é o mesmo que ocorre para
operandos básicos. Se a condição do comutador conectado do operando for avaliada
como True, o operando será exibido. Se a condição da chave for False, o operando
não será exibido.
No entanto, os operandos do elemento têm o recurso adicional de criar elementos -
incluí-los em listas e, se o tipo de referência do operando do elemento for Definir,
202
definir o

203
 elemento no modelo de simulação. Como mais de uma instância de módulo em um
modelo pode ter um operando de elemento que acessa o mesmo elemento, existe o
potencial de que o operando de definição do mesmo elemento possa ser "ativado" em
algumas instâncias do módulo e "desativado" em outras.
No caso de um conflito desse tipo, o Arena retém o elemento na lista de elementos,
desde que qualquer operando que crie o elemento não seja desativado (ou seja, não
possui um comutador conectado ou um comutador verdadeiro). A mesma regra se
aplica às propriedades de um elemento.
Nota: Se um operando de elemento tiver um comutador conectado em uma
definição de módulo, todos os operandos de propriedade que definem propriedades
desse elemento também deverão ser alternados para garantir que não haja
nenhuma condição sob a qual o elemento possa ser desligado e uma ou mais
propriedades ativadas. .

Por exemplo, o módulo Record contém um operando, Nome do Contador, que é um

operando de elemento que define um elemento Contadores. Esse operando é ativado
ou desativado em uma instância do módulo com base na seleção para o tipo
(Contador, Estatísticas da entidade, Intervalo de tempo, Entre ou Expressão). Se uma
instância do módulo Record tiver um tipo de Contagem e nomear o contador Itens
Concluídos, o contador Itens Concluídos será criado.
Outra instância do módulo Record pode ser colocada no modelo que também conta
no contador Itens Concluídos. Se o primeiro módulo Registro foi editado e o tipo
alterado para Estatísticas da Entidade, o operando Itens Concluídos será desativado
nessa instância do módulo. No entanto, como o contador Itens concluídos ainda está
ativado (ou seja, na segunda instância do módulo Record), ele ainda existe no
modelo de simulação. Se o segundo módulo Registro for excluído (ou seu tipo
alterado para algo diferente de Contagem), o contador Itens Concluídos será
removido da lista de elementos, pois nenhum módulo mudou em referência a ele.

Tipos de elementos especiais

Os tipos de elementos de modelo que podem ser referenciados em um modelo
incluem cada um dos tipos de elementos definidos no experimento SIMAN.
(Consulte a Ajuda para obter a documentação completa sobre o experimento SIMAN
e o painel Elementos.) Fornecemos três classificações adicionais de elementos no
Arena para tratar de circunstâncias especiais que você pode enfrentar ao criar
modelos. Essas classificações de elementos são descritas nas seções a seguir.
Consulte o apêndice "Tabelas" para obter uma lista completa desses tipos de
elementos adicionais e suas propriedades.
Elementos de comprimento fixo
Muitos dos tipos de elementos no Arena têm uma ou mais propriedades que podem
ter um conjunto repetido de valores, como os valores iniciais de uma variável ou as
falhas associadas a um recurso (conforme ilustrado anteriormente neste capítulo).
Os modelos podem ser projetados para fornecer valores a essas propriedades
repetidas, colocando um grupo de repetição de propriedades e os operandos de
propriedades apropriados em uma definição de módulo.
Em alguns casos, convém criar um módulo que coloque um valor em um índice
específico no operando de repetição. Por exemplo, você pode estabelecer que o
primeiro valor em uma receita é o nome do recurso a ser usado em uma determinada
etapa da tarefa, o segundo valor é o tempo de processamento e o terceiro valor é o
rendimento para um determinado tipo de tarefa. Se você quisesse exibir essas
informações como operandos não repetitivos em uma caixa de diálogo, não seria
possível usar operandos de propriedades (porque o elemento da receita especifica
que os valores estão em um grupo de repetição).
Adicionamos tipos de elementos que espelham cada um dos elementos que contêm
valores repetidos. Esses tipos de elementos adicionais são chamados de elementos de
comprimento fixo. Esses elementos de comprimento fixo contêm um conjunto
predefinido de valores para a propriedade de repetição; eles são nomeados usando o
prefixo Fixed_. Por exemplo, o elemento Fixed_REC50 possui 50 propriedades de
atribuição seguidas por uma propriedade de atribuição repetida; o elemento
RECIPES padrão contém apenas o grupo de repetição para atribuições.
Elementos adicionais de comprimento fixo contêm um número predefinido de
propriedades de repetição no grupo de repetição. Esses elementos são nomeados
usando o prefixo Fixed_ e um sufixo R. Esses elementos permitem definir uma
matriz uni ou bidimensional em que cada linha na matriz é uma tupla individual. Por
exemplo, o elemento Fixed_VAR10R possui 10 propriedades de valor inicial
predefinidas por grupo de repetição.
Você usa os elementos de comprimento fixo exatamente como os elementos
padrão, definindo operandos de elementos para criar elementos e operandos de
propriedades para definir os valores das propriedades do elemento. Elementos de
comprimento fixo são gerados junto com elementos padrão na geração do modelo.
Nota: As listas e sublistas de elementos são separadas uma da outra, mesmo para
os tipos de elementos relacionados (por exemplo, elementos Fixed_REC50 e
RECIPES).

Lista de elementos ocultos

Você pode encontrar uma circunstância em que deseja fornecer ao modelador uma
lista suspensa de valores, mas não deseja que esses valores sejam gravados no
arquivo experimental do SIMAN. Adicionamos um tipo de elemento, chamado de
elemento oculto, que permite definir uma lista de elementos, mas que não será
usada para gerar o modelo de simulação.
O elemento oculto funciona como um elemento padrão, mas não grava diretamente
seus valores no arquivo experimental do SIMAN. Na caixa de diálogo da propriedade
LogicProperties, um operando que é elemento de tipo pode ser definido como um tipo
de elemento oculto, selecionando Oculto na lista de tipos de elementos disponíveis.
Esta opção aparece no final da lista de tipos de elementos. Não há propriedades
associadas ao tipo de elemento oculto.
Um exemplo do uso de uma lista oculta é o seguinte. Nos módulos do modelo Arena
(Processo Básico, Processo Avançado e Transferência Avançada), cada módulo que
você coloca recebe um nome, com base no tipo de módulo. Por exemplo, se você
colocar o módulo Create, Process e Dispose, eles serão nomeados automaticamente
Create 1, Process 1 e Dispose 1. Você pode editar esses módulos e alterar o nome do
módulo, o que altera o identificador do módulo que você vê no usuário Visão. Cada
um dos campos de nome possui uma lista suspensa, que é uma lista de todos os
nomes de módulos no modelo. Eles não são gravados em nenhum elemento SIMAN,
pois existem para o benefício do usuário na identificação do módulo. Figura
10.11 mostra as propriedades de design do operando Name na definição do módulo
Create.
Figura 10.11 Propriedades de design da caixa de diálogo do operando Name no
módulo Create
O elemento oculto também pode ser usado com propriedades de grupo de
repetição. Como discutido anteriormente, todos os operandos contidos em uma
propriedade de grupo de repetição devem ser definidos como um elemento ou
operando de propriedade. O elemento oculto pode ser usado quando você possui
um operando que não define um elemento ou uma propriedade, mas está contido
em uma propriedade de grupo de repetição.

Elementos invertidos
Os elementos invertidos são usados quando você deseja criar um módulo que
permita ao modelador criar uma única tupla de grupo de repetição para cada
instância de um módulo. Por exemplo, você pode desejar que um módulo individual
defina um membro de um conjunto de recursos sem precisar definir todos os
membros do conjunto de recursos em um único módulo. Existem cinco elementos
invertidos disponíveis: Inv_DISTANCES para criar um elemento de distâncias,
Inv_LINKS para criar um elemento de redes, Inv_SEGMENTS para criar um
elemento de segmentos, Inv_SETS para criar um elemento de conjuntos e
Inv_Statesets para criar um conjunto de estados de recursos.
A diferença entre um elemento invertido e um elemento padrão está relacionada à
forma como os elementos e propriedades são definidos. Por exemplo, o elemento
Segmentos padrão define um nome de segmento. Suas propriedades são estação
inicial, próxima estação e comprimento. O elemento Inv_SETS define um elemento
cujo valor padrão é usado internamente.
As propriedades desse elemento são estação inicial, próxima estação, comprimento
e nome do conjunto de segmentos. O valor do elemento Inv_SEGMENTS deve ser
exclusivo e geralmente é criado como uma combinação de valores visíveis do
operando (explicado no exemplo a seguir).
Um módulo que usa um elemento invertido combina elementos padrão visíveis com
elementos invertidos ocultos. Na geração do modelo, todas as instâncias de um
módulo que usam Inv_SEGMENTS e têm o mesmo valor da propriedade name do
conjunto de segmentos são convertidas e classificadas para criar um elemento de
segmentos padrão válido.
Por exemplo, suponha que o design do modelo inclua um módulo de segmento em
que os usuários possam definir a animação de um transportador enquanto define o
conjunto de segmentos, usando o elemento Inv_SEGMENTS. A Figura 10.12
mostra a caixa de diálogo de um módulo de segmento animado.
Figura 10.12 Caixa de diálogo para o módulo de segmento animado

A Figura 10.13 mostra a visualização Operand Explorer do design da caixa de diálogo

do módulo.

Figura 10.13 Visualização Operand Explorer do design da caixa de diálogo do

módulo de segmento animado

O design da caixa de diálogo deste módulo consiste em quatro operandos ocultos

(Nome, BegN, EndN e SetN) e quatro operandos visíveis (Beg, End, Set e Length).
O operando Name é definido como o elemento invertido Inv_SEGMENTS e suas
propriedades são BegN (nome da propriedade Beginning Station), EndN (nome da
propriedade Next Station), SetN (nome da propriedade Segment Set ID) e Length
(nome da propriedade Length).
As propriedades de design do operando Name são mostradas na Figura 10.14.

Figura 10.14 Propriedades do design do operando Name

Na Figura 10.14, veja que o valor padrão para o operando é `Beg``End``Set. Isso
fornece ao operando um valor padrão exclusivo. Os operandos Beg e End são
operandos do tipo elemento visível que definem elementos padrão da estação. Eles
correspondem aos campos suspensos Estação inicial e final na caixa de diálogo do
módulo Segmento. O operando Set é um operando do tipo elemento visível que define
um elemento padrão dos segmentos.
Os valores padrão do operando da propriedade BegN e EndN referenciam os
valores do operando Beg e End, respectivamente. A Figura 10.15 mostra as
propriedades de design do operando BegN.

Figura 10.15 Propriedades do projeto do operando BegN

O operando SetN também é uma propriedade oculta cujo valor padrão faz
referência ao valor do operando Set.
Quando um módulo é projetado dessa maneira, cada instância do módulo cria uma
tupla do elemento de segmentos. O Arena salva e classifica corretamente todas as
instâncias do módulo para que as estações inicial e final estejam na ordem correta.
Os outros dois elementos invertidos de manipulação de material (Inv_LINKS e
Inv_DISTANCES) são usados da mesma maneira.
 O elemento Inv_SETS e os elementos Inv_Statesets são ligeiramente diferentes. Os
elementos Inv_SETS e Inv_STATESETS são o oposto dos elementos conjuntos e
estados padrão. Os elementos conjuntos e estados padrão definem um nome de
conjunto e suas propriedades são membros do conjunto. Os elementos Inv_SETS e
Inv_Statesets definem um membro do conjunto como o valor do elemento e a
propriedade desse elemento é o nome do conjunto. Na geração do modelo, todas as
instâncias de Inv_SETS com o mesmo valor da propriedade nome do conjunto são
combinadas em um elemento de conjuntos padrão. Da mesma forma, todas as
instâncias de Inv_STATESETS com o mesmo valor da propriedade name do conjunto
de estados são combinadas em um elemento de conjuntos de estados padrão. Essa
abordagem permite a flexibilidade de definir membros individuais do conjunto de
diferentes módulos.
Atualmente, os modelos Arena e SIMAN não usam nenhum dos tipos de
elementos invertidos.

210
UMA Diretrizes de design de
modelo
Embora não exista uma melhor maneira de criar um módulo ou modelo, o design
cuidadoso e consistente pode facilitar muito o uso e a manutenção de um modelo.
Isso é especialmente importante se você distribuirá seu trabalho a outras pessoas
dentro ou fora da organização. A lista a seguir de diretrizes e dicas pode ser útil
para fornecer o melhor ambiente de simulação para você ou outras pessoas.

Design da caixa de diálogo (janela de

design da caixa de diálogo)
Caixa de diálogo
 Planejar com antecedência. Tente criar uma imagem das caixas de diálogo
para os módulos no painel do modelo e coloque as informações em um
formato consistente.
 Use os controles Line e GroupBox para agrupar informações relacionadas em uma
caixa de diálogo.
 Use caixas de diálogo secundárias em vez de uma única caixa de diálogo grande.
 As caixas de diálogo secundárias geralmente não devem conter operandos
necessários, a menos que sejam ativadas pelo usuário.
 Em um painel de modelo, use designs consistentes na interação do modelador
com caixas de diálogo. Se a ordem de tabulação do teclado normalmente se
move verticalmente entre operandos, tente evitar os casos em que a tecla Tab se
move para um operando localizado à esquerda ou à direita.
 Tente criar a caixa de diálogo para que haja uma certa simetria, mas evite
grandes espaços vazios.

Objetos de operando
 O texto do prompt deve ser conciso; quando as abreviações forem usadas,
fique muito claro qual termo é abreviado.
 Os controles TextBox e ComboBox devem ter prompts não em branco, a menos
que operandos próximos ou texto estático aponte claramente o significado do
 operando de texto ou de combinação.
 Se as opções de um controle RadioButtonGroup tiverem um significado claro,
um rótulo de prompt será opcional. No entanto, se houver possibilidade de
ambiguidade ou incompreensão, forneça um rótulo imediato.
 A • TEMPLATE DESIGN GUIDELINES

 Os avisos devem ser claros e conter um mínimo de jargão do SIMAN.

 Se um operando for referenciado por um campo obrigatório de um módulo na
janela lógica, ele também deverá ser solicitado no design da caixa de diálogo do
módulo.
 O tipo de dado de um operando deve ser igual ou mais restritivo que o tipo de
dado de qualquer campo que o referencie em uma instância do módulo na janela
lógica.
 Use opções para ativar ou desativar os controles, para que os campos não
aplicáveis não sejam exibidos.
 Tente não colocar os controles ComboBox perto da parte inferior de uma caixa
de diálogo alta. Arena solta a lista e a exibe acima da caixa, se a caixa for
exibida fora da tela. Embora isso permita que um modelador veja a lista inteira
que você definiu, não é tão conveniente quanto uma caixa que fica abaixo da
caixa de edição.
 Controle RadioButtonGroup vs. controle ComboBox
□ Use um grupo de botões de opção se houver amplo espaço na caixa de
diálogo ou se a escolha for muito importante.
□ Use uma caixa de combinação se o campo não for alterado frequentemente ou
se o espaço for limitado.
 Controle CheckBox vs. controle RadioButtonGroup
□ Use a caixa de seleção somente se o significado da escolha (Marcado ou
Desmarcado) for muito claro.
□ Use o grupo de botões de opção se desejar limitar o usuário apenas às entradas
definidas.

Dicas úteis para definir objetos na janela de design da

caixa de diálogo
 Use nomes significativos de operando. Eles serão usados para prompts padrão
e para os títulos das colunas com Importação ou Exportação de Dados do
Módulo.

Geral
 Os pontos de entrada e saída do módulo não devem ser ocultados para que o
módulo possa ser usado na definição de outro módulo (ou seja, um operando
Label ou Next Label deve aparecer na caixa de diálogo do módulo para que uma
referência possa ser inserida quando o módulo for colocado na janela lógica de
outra definição de módulo).
212
 A • TEMPLATE DESIGN GUIDELINES
 Use a funcionalidade Módulo criado automaticamente para criar
automaticamente módulos de "dados" a partir de módulos "lógicos".

213
Ícone do painel
 Mantenha o rótulo do texto do ícone e use o mesmo tipo e tamanho de
fonte para todos os módulos.
 Seja consistente em um modelo com o uso de cores e estilos.
 Mantenha o ícone simples.
 Use tipos de design semelhantes para os ícones do painel; evite misturar ícones do
painel 2D e 3D.
 Se o módulo tiver um recurso na visualização do usuário, tente representá-lo no
ícone do painel desenhando uma versão simplificada da imagem ociosa ou
ocupada do recurso.
 Se os módulos estiverem relacionados a outros, os ícones podem representar esse
relacionamento.
 Apresente os módulos lógicos e os dados ”juntos em um painel de modelo,
como é feito nos painéis Processo básico, Processo avançado e Transferência
avançada do modelo Arena. Coloque o agrupamento mais importante na parte
superior do painel.

Visualização do usuário
 Coloque a alça do módulo na parte inferior da visualização do usuário.
Considere usar um operando (como o nome do módulo) como o texto do
identificador do módulo.
 O fundo estático que não deve aparecer durante uma simulação deve ser
desenhado na camada oculta.
 Os operandos na visualização do usuário devem ser mantidos no mínimo
para evitar confusão nas janelas do modelo.
 Não agrupe objetos de animação na visualização do usuário; embora os objetos
ainda possam ser editados, os identificadores individuais não aparecem quando
você seleciona um objeto agrupado.
 Todos os objetos de animação devem referenciar operandos do módulo na
entrada de expressão ou identificador, porque esse valor não pode ser alterado
pelo modelador em uma instância do módulo.
 Anexe comutadores a objetos de animação que correspondem a outros itens do
módulo que podem ser desativados.
Lógica do módulo
 Use objetos Draw e vistas nomeadas na janela lógica para identificar várias
partes da lógica do módulo.
 Verifique primeiro a lógica do módulo em uma janela do modelo para poder
interagir com o modelo e visualizar uma animação detalhada. Em seguida, use a
área de transferência do Arena para transferir a lógica para a janela lógica de
uma definição de módulo e adicione as referências ou comutadores apropriados
de operando.
 Baseie seus módulos em SIMAN Blocks and Elements. Isso permite definir
elementos através da janela lógica ou da janela de design da caixa de diálogo.

Convenções de nomenclatura
 Quando um módulo contém uma designação de estação, o nome da estação
deve ser fornecido pelo usuário. Outros operandos podem receber nomes
padrão com base no nome da estação com um sufixo.
 O uso dos seguintes sufixos fornecerá consistência aprimorada e ajudará a
impedir o uso múltiplo do mesmo nome:
`Nome da estação`_R - Recursos
`Nome da estação`_Q - Filas
`Nome da estação`_S - Armazenamentos
`Nome da estação`_C - Contadores
`Nome da estação`_Ta - Tallies
 Forneça um prefixo padrão aos arquivos do painel do modelo se você criar
e compartilhar vários arquivos.
 Se você criar módulos com nomes semelhantes aos módulos em outros modelos,
use um prefixo no título da caixa de diálogo principal do módulo (por exemplo,
AGV_Transport) para diferenciá-lo dos outros módulos que executam uma
atividade semelhante.

Documentação do modelo
Recomendamos que você forneça documentação de modelos para seu próprio uso ou
para outros. É particularmente útil fornecer informações úteis que podem ser
acessadas no software. Isto pode ser feito de várias maneiras.
 Use texto estático (controle de texto) para fornecer uma breve descrição em uma
caixa de diálogo.
  Forneça um arquivo de texto (por exemplo, tplname.txt) que descreva cada
módulo em seu painel de modelos.
Com a ajuda de uma ferramenta de criação de ajuda, crie e "conecte" a verdadeira ajuda
on-line ao seu modelo. Isso é explicado em detalhes no apêndice C.

Vestígio
Embora o rastreio de baixo nível esteja automaticamente disponível em todos os
blocos SIMAN, isso geralmente não é útil para um modelador menos experiente. O
bloco TRACE pode ser usado em uma definição de módulo para fornecer
rastreamento suplementar específico ao módulo. Seguem algumas diretrizes sobre
o design das informações de rastreio para seus módulos.
 Como o número da entidade e o identificador do módulo são gerados
automaticamente durante a execução da simulação (fornecendo um cabeçalho
para cada nova mensagem de rastreamento), essas informações não precisam
ser incluídas no rastreamento do módulo.
 Para distinguir as mensagens geradas dos cabeçalhos dos módulos e do
rastreio de baixo nível, recomendamos que cada mensagem comece com um
hífen na coluna 1 (por exemplo, Aguardando caixa \ n).
 Como nem sempre é possível avaliar todas as expressões com precisão, é mais
consistente escrever a própria expressão (no formato) em vez de escrevê-la
como argumento.
 Use a palavra-chave STR para escrever nomes de símbolos em vez de números
(por exemplo, um nome de recurso).

Estatísticas e relatórios
Embora a animação seja a parte mais visível da construção do modelo,
geralmente é a estatística sobre a qual a maioria das decisões é tomada.
 Forneça estatísticas opcionais sobre a maioria dos itens nos quais é provável
que um modelador tenha interesse.
 Para evitar complexidade e confusão, defina as estatísticas padrão a serem
coletadas apenas nos itens principais.
 O nível mais básico (e padrão) das estatísticas deve aparecer no relatório de
resumo padrão.
 O elemento Relatórios pode ser usado para categorizar estatísticas por
módulo ou outro agrupamento lógico.
 O elemento Reportlines pode ser usado para gerar um relatório profissional
totalmente personalizado por módulo ou outro agrupamento lógico.
 Use a palavra-chave STR para escrever nomes de símbolos em vez de
números (como um recurso).
B Tabelas
Elementos e propriedades
Elementos padrão
Listados abaixo estão os elementos e propriedades padrão (SIMAN) disponíveis para a
construção do módulo. Para mais informações sobre um elemento específico,
consulte a Ajuda.
Nota: As propriedades que são propriedades de grupo de repetição são indicadas com
um (R). Os operandos incluídos são recuados após o nome do grupo de repetição.

ACTIVITYAREAS
Elemento Propriedades Área
de atividade
principal de nível de
organização
Estatísticas automáticas
geram categoria de
estados automáticos
Identificador de
estados automáticos

Elemento CHEGADAS Propriedades

Tipo Tipo
ID Hora
Intervalo ou
deslocamento
da tecla
Lotes máximos
Tempo
217
máximo
Tamanho do
lote

218
ARENA TEMPLATE DEVELOPER’S GUIDE

Elemento CHEGADAS Propriedades

Valor da ID
Variável de
Atribuições (R)

Elemento ATTRIBUTES Propriedades

Número
Índice de matriz
2D Tipo de
dados de índice
de matriz 2D
Valores iniciais
(R) Valor

Elemento BEGIN Propriedades

Listagem
Executar controlador

Elemento BLOCKAGES Propriedades

Número
Expressões de
prioridade de
prioridade global
de bloqueios
iniciais

Propriedades do elemento CONTÍNUO

Number of Dif Eq
Número de State Eq
ARENA TEMPLATE DEVELOPER’S GUIDE
Tamanho mínimo
do passo Tamanho
máximo do passo
Propriedades do elemento CONTÍNUO

Método do
intervalo de ponto
de salvamento
Erro absoluto
Gravidade
relativa do
erro
Gravidade cruzada

Elemento TRANSPORTADORES Propriedades

Velocidade do
ID do conjunto
de segmentos
numéricos
Status do
compriment
o da célula
Células máximas por
tipo de entidade
Acumulação
Estatísticas
automáticas de
comprimento Gerar
estatísticas
automáticas
Categoria
Identificador
automático de
estatísticas
 Elemento COUNTERS Propriedades

Limite
de
número
Arquivo de
saída da
opção inicial
ID do
relatório
Tipo de
dados
Categoria ID
do processo

Elemento CSTATS

Proprieda
des
Número
Nome
Arquivo de
saída ID do
relatório
Tipo de
dados
Categoria
ID do
processo

220
 Elemento DISCRETE Propriedades

Número Máximo de
Entidades Número de
Atributos Maior
Número da Fila Maior
Número da Estação
Atributo de Animação

220
Elemento DISTANCES Propriedades
Estação (R)
ID da estação inicial
Distância da ID da
estação final

DISTRIBUIÇÕES
Elemento

Prpropried
ades Número
Dist Índice
Dist1 Dist
Índice2
Valores Dist
(R) Valores

Elemento DSTATS

Proprieda
des
Número
Nome
Arquivo de
saída ID do
relatório
Tipo de
dados
Categoria
ID do
 processo

DSTATS_PERIODIC
Elemento Propriedades
Número
Arquivo de Saída
de Expressão
SIMAN
Elemento DSTATS Propriedades

ID do
relatório
Tipo de
dados
Categoria ID
do processo
Hora de
início
Duração
Tempo de
repetição

Elemento ENTITIES Propriedades

Número da
imagem
inicial
Taxa inicial de custo de
manutenção Custo inicial
de VA
Custo inicial de
NVA Custo inicial
de espera Custo
inicial Tran Inicial
Outros custos
Estatísticas
automáticas Geram
estatísticas
222
 automáticas
Categoria
Identificador
automático de
estatísticas

Elemento EVENTS Propriedades

Direção de
travessia variável
Tolerância de
cruzamento de
valor limite

223
Propriedades do elemento EXPRESSIONS
Número
Índice de matriz
2D Índice de
matriz 2D Tipo
de dados Arquivo
vinculado
Conjunto de
registros
vinculado
Expressão Valores (R)
Expressão

Elemento FAILURES Propriedades

Número
Tipo
Tempo ou contagem
entre a duração
Estado

Elemento FILES

Propriedade
s Nome do
sistema
numérico
Tipo de acesso
Estrutura de
comprimento
de acesso
Fim do arquivo
Ação Comentário
Caractere Inicializar
Opção Nome do
Conjunto de
Registros
Elemento FILES Propriedades

Recordset CommandText
Recordset CommandType

Propriedades do elemento FREQUENCIES

Número
Tipo Nome
Arquivo de
Saída ID
do
Relatório
Tipo de
Dados
ID do
processo da
categoria de
dados
Valor das
categorias (R)
ou valor do
intervalo
Opção de
categoria de
categoria de alto
valor
FREQUÊNCIAS_
Elemento PERIÓDICO Propriedades

Número
Tipo de
expressão
Arquivo de
saída ID do
relatório
Tipo de
dados
Categoria de
dados ID do
processo Hora
de início
Duração Hora
de repetição
Valor das
categorias (R)
ou valor do
intervalo
Opção de
categoria de
categoria de alto
valor

Elemento INCLUDE Propriedades

Descrição do arquivo

Elemento INICIALIZAR Propriedades

Valor
INTERSECÇÕES
Elemento

Propriedade
s Número
Comprimento
de viagem
Regra de seleção de
link Regra ID do
atributo Fator de
alteração de velocidade

Elemento LEVELS Propriedades

Número
Índice de matriz
1-D Índice de
matriz 2-D
Valores iniciais
(R) Valor

Elemento LINKS Propriedades

Número
ID de interseção inicial
Direção de início End ID
de interseção final
Número de zonas de
comprimento de
cada tipo de link de
zona
Fator de mudança de velocidade
Elemento NETWORKS Propriedades
Links
numérico
s (R)
Link inicial
Link final

Elemento NICKNAMES Propriedades

Nome ou constante

Elemento OUTPUTS Propriedades

Número
Nome do
arquivo de
saída ID do
relatório
Tipo de
dados
Categoria
ID do
processo

Propriedades do elemento PARAMETERS

Número
Valores
(R) Valor

Elemento PICTURES Propriedades

Número
Elemento PROJECT Propriedades
Título
Nome do
analista Mês
Dia
ano
Cálculo de
resumo do
relatório
Entidades
Recursos
Filas
Transportador
as
Transportador
as Processos
Estações
AtividadeÁre
as Tanques

Elemento QUEUES Propriedades

Número
Expressão da
regra de critério
de classificação
Gerar estatísticas
automáticas de bloco
associado / SHARED
 Categoria de
estatísticas
automáticas
Identificador de
estatísticas
automáticas
Elemento RANKINGS Propriedades

Critério de
Classificação
Expressão de
Classificação

Elemento TARIFAS Propriedades

Número
Índice de matriz
1-D Índice de
matriz 2-D
Valores iniciais
(R) Valor

Elemento RECIPES Propriedades

Statics (R)
Static Name
Value

Elemento REDIRECTS Propriedades

Número de
interseções de
ID de rede (R)
ID de interseção inicial
ID de interseção final ID
de próximo interseção
 Elemento REPLICATE Propriedades

Número de réplicas
Tempo de início
Comprimento da
replicação Inicializar
Sistema Inicializar
estatísticas Período de
aquecimento Condição
de término Nome da
DLL
Horas por dia
Unidades de
tempo base
Modo de
execução Tempo
real Fator de
tempo real
Data de início da simulação
Hora Incluir unidades RC
fracionárias

REPORTLINES Propriedades do elemento

Formato
do
número
de
identifica
ção do
230
 relatório
Expressões (R)
Expressão

230
Elemento REPORTS Propriedades

Número
Nome do
sistema
Título
Formato
de
classific
ação de
título

Elemento RECURSOS Propriedades

Número
ID de conjunto de
regras de entidade de
capacidade ou de
número inteiro de
agendamento ou ID
de agendamento
Tipo de
recurso de
estado inicial
ID do mapa
Velocidade
Posição inicial
Posição ID
Zona
Custo
ocupado
Custo
ocioso
Custo de
uso
Tipo de categoria
ID de falha
de falha
(R)
Regra de entidade de falha
Elemento RECURSOS Propriedades

Estatísticas
automáticas Gerar
categoria
automática de
estatísticas
Identificador
automático de
estatísticas
Eficiência básica (não é mais suportada) ID
do cronograma de eficiência (não é mais
suportada)

Elemento RULES Propriedades

Expressão de
regra de regra
de seleção

Elemento HORÁRIOS Properties

Tipo de programação
Tipo de formato (o tipo de formato de calendário não é
mais suportado) Fator de escala
Unidades de tempo
Valores
(R) Valor
Duração

Elemento SEEDS Propriedades

Opção de
232
 Inicialização do
Valor Inicial

Elemento SEGMENTS Propriedades

Estação de Início
Próximas
estações (R)
Próxima estação

233
Elemento SENSORES Propriedades

Número
Nome do
tanque
Localização
Tipo
Localização
Etiqueta do bloco
de direção de
cruzamento
Estado inicial

Elemento SEQUENCES Propriedades

Número
Estações (R)
Atribuições de
identificação de
estação (R)
Valor
Variável

Elemento SETS Propriedades

Número
Membros (R)
Membro

Elemento STATESETS Propriedades

Número
Estados (R)
Nome do
 Estado
Stateset Tipo

Elemento STATICS Propriedades

Valor padrão
Elemento STATIONS Propriedades

Número
Intersecção ID
Receita ID
Área de atividade
pai Estatísticas
automáticas Gerar
estatísticas
automáticas
Categoria
Identificador
automático de
estatísticas

Elemento STORAGES Propriedades

Número

Elemento TABLES

Proprieda
des
Número
baixo valor
Incremento fixo
Valores dependentes
(R) Valor
dependente

Elemento TALLIES
Proprieda
des
Arquivo de
saída
numérica
ID do
relatório
Categoria
do tipo de
dados ID
do
processo
Elemento TANKS

Proprieda
des
Número
Capacidade
Nível
Inicial
Nome da variável de
entrada Nome da
variável de saída
Categoria de
estatísticas do
relatório
Identificador
Regulador
Nome
Maximum Rate
Time Units

Elemento TAREFAS

Propriedad
es Número
da tarefa
Exec Expr
Parâmetro
de
formato
235
Elemento TRACE Propriedades
Horário de
início Condição
de horário de
término
Expressões (R)
Expressão

236
TRANSPORTADORES
Elemento Propriedades
Número Número
de Unidades
ID do mapa do
tipo de mapa do
sistema
Desaceleraç
ão da
aceleração
da
velocidade
de controle
Velocidade de giro
Dados da
unidade (R)
Posição inicial
Posição ID
Zona
Status
inicial
Tamanho do
veículo
Tamanho
Inteiro
Estatísticas
automáticas Gerar
categoria
automática de
estatísticas
Identificador
automático de
estatísticas
Elemento VARIABLES Propriedades
Número
Índice de matriz
2D Tipo de
dados de índice
de matriz 2D
Limpar Tipo
de Categoria
de Opção
Arquivo vinculado do
tipo de categoria de
resposta
Conjunto de registros vinculado
Tempo de leitura do arquivo
Valores iniciais
(R) Valor

Elementos invertidos
Listados abaixo estão os elementos invertidos e suas propriedades, conforme
descrito no capítulo "Elementos".

Inv_DISTANCES
Elemento Propriedades
ID da estação inicial
ID da estação final
Distância
ID do conjunto de distâncias
Elemento Inv_LINKS Propriedades
Número
ID de interseção inicial
Direção de Início
ID de interseção final
Direção final
Número de zonas
Comprimento de cada zona
Tipo de Link
Fator de mudança de velocidade
ID de rede

Elemento Propriedades
Inv_SEGMENTS
Estação de Início
Próxima estação
comprimento
ID do conjunto de segmentos

Elemento Inv_SETS Propriedades

Nome do conjunto

Elemento Propriedades
Inv_STATESETS
Propriedades
Tipo de conjunto de estados
ID do conjunto de estados
Elementos de comprimento fixo
Listados abaixo estão os elementos de comprimento fixo e suas propriedades,
conforme descrito no capítulo "Elementos". O elemento padrão associado ao
elemento de comprimento fixo é apresentado ao lado do nome do elemento entre
parênteses. As propriedades repetíveis são indicadas com um (R).

Elemento Fixed_ARR5
(Chegadas) Propriedades
Tipo
ID do tipo
Tempo
Intervalo ou
Chave
Deslocamento
Lotes máximos
Tempo máximo
Tamanho do
batch
ID da variável 1
Valor 1
ID da variável 2
Valor 2
ID da variável 3
Valor 3
ID da variável 4
Valor 4
ID da variável 5
Valor 5
Valor da ID
Variável de
Atribuições (R)
 Elemento Fixed_ARR50
(Chegadas) Propriedades
Tipo
ID do tipo
Tempo
Intervalo ou
Chave
Deslocamento
Lotes máximos
Tempo máximo
Tamanho do
batch
ID da variável 1
Valor 1
ID da variável 2
Valor 2
••••
ID da variável
50
Valor 50
Valor da ID
Variável de
Atribuições (R)

Elemento Fixed_ATT10R
(Atributos) Propriedades
Número
Índice de matriz
1-D
Índice de matriz
2D
Tipo de dados

240
Elemento Fixed_ATT10R
(Atributos) Propriedades
Valores iniciais
(R) Valor 1
Valor 2
Valor 10

Elemento
Fixed_ATT50 Propriedades
(atributos)
Número
Índice de matriz
1-D
Índice de matriz
2D
Tipo de dados
Valor 1
Valor 2
Valor 50

Valores iniciais
(R) Valor

Elemento Fixed_EXP2R
(Expressões) Propriedades
Número
Índice de matriz 1-D
Índice de matriz 2D
Tipo de dados
Valores de expressão
(R) Expressão 1
Expressão 2
Uso
Descrição
Elemento Fixed_EXP3R
(Expressões) Propriedades
Número
Índice de matriz 1-D
Índice de matriz 2D
Tipo de dados
Valores de expressão
(R) Expressão 1
Expressão 2
Expressão 3
Uso
Descrição

Elemento Fixed_EXP4R
(Expressões) Propriedades
Número
Índice de matriz 1-D
Índice de matriz 2D
Tipo de dados
Valores de expressão
(R) Expressão 1
Expressão 2
Expressão 3
Expressão 4
Uso
Descrição

242
Elemento Fixed_EXP7R
(Expressões) Propriedades
Número
Índice de matriz 1-D
Índice de matriz 2D
Tipo de dados
Valores de expressão
(R) Expressão 1
Expressão 2
Expressão 7

Uso
Descrição

Elemento Fixed_EXP30R
(Expressões) Propriedades
Número
Índice de matriz 1-D
Índice de matriz 2D
Tipo de dados
Valores de expressão
(R) Expressão 1
Expressão 2
Expressão 30

Uso
Descrição
Elemento Fixed_EXP5
(Expressões) Propriedades
Número
Índice de matriz 1-D
Índice de matriz 2D
Tipo de dados
Expressão 1
Expressão 2
••••
Expressão 5
Expressões (R)
Expressão
Uso
Descrição

Elemento Fixed_EXP10
(Expressões) Propriedades
Número
Índice de matriz 1-D
Índice de matriz 2D
Tipo de dados
Expressão 1
Expressão 2
••••
Expressão 10
Expressões (R)
Expressão
Uso
Descrição
Elemento Fixed_EXP10R
(Expressões) Propriedades
Número
Índice de matriz 1-D
Índice de matriz 2D
Tipo de dados
Valores de expressão
(R) Expressão 1
Expressão 2
Expressão 10

Uso
Descrição

Elemento Fixed_EXP15
(Expressões) Propriedades
Número
Índice de matriz 1-D
Índice de matriz 2D
Tipo de dados
Expressão 1
Expressão 2
••••
Expressão 15
Expressões (R)
Expressão
Uso
Descrição
Elemento Fixed_EXP20
(Expressões) Propriedades
Número
Índice de matriz 1-D
Índice de matriz 2D
Tipo de dados
Expressão 1
Expressão 2
••••
Expressão 20
Expressões (R)
Expressão
Uso
Descrição

Elemento Fixed_EXP25
(Expressões) Propriedades
Número
Índice de matriz 1-D
Índice de matriz 2D
Tipo de dados
Expressão 1
Expressão 2
••••
Expressão 25
Expressões (R)
Expressão
Uso
Descrição
Elemento Fixed_EXP50
(Expressões) Propriedades
Número
Índice de matriz 1-D
Índice de matriz 2D
Tipo de dados
Expressão 1
Expressão 2
••••
Expressão 50
Expressões (R)
Expressão
Uso
Descrição

Elemento Fixed_FRE50
(Frequências) Propriedades
Número
Tipo
Nome
Arquivo de saída
ID do relatório
Valor ou intervalo 1
Valor 1
Alto valor 1
Categoria 1
Categoria Opção 1
Valor ou intervalo 2
Elemento Fixed_FRE50
(Frequências) Propriedades
Valor 2
Alto valor 2
Categoria 2
Categoria Opção 2
••••
Valor ou intervalo 50
Valor 50
Alto valor 50
Categoria 50
Categoria Opção 50
Valor das
categorias (R)
ou valor do
intervalo
Opção de
categoria de
categoria de alto

Elemento Fixed_LEV10R
(Níveis) Propriedades
Número
Índice de matriz
1-D
Índice de matriz
2D
Valores iniciais
(R) Valor 1
Valor 2
Valor 10
Elemento Fixed_LEV50
(Níveis) Propriedades
Número
Índice de matriz
1-D
Índice de matriz
2D
Valor 1
Valor 2
••••
Valor 50
Valores iniciais
(R) Valor

Elemento Fixed_PAR50
(Parâmetros) Propriedades
Número
Índice de matriz
1-D
Índice de matriz
2D
Valor 1
Valor 2
••••
Valor 50
Valores iniciais
(R) Valor
 Elemento Fixed_RAT10R
(Cotações) Propriedades
Número
Índice de matriz
1-D
Índice de matriz
2D
Valores iniciais
(R) Valor 1
Valor 2
Valor 10

Elemento Fixed_RAT50
(Cotações) Propriedades
Número
Índice de matriz
1-D
Índice de matriz
2D
Valor 1
Valor 2
••••
Valor 50
Valores iniciais
(R) Valor

250
Elemento Fixed_REC20
(Receitas) Propriedades
Nome estático 1
Valor 1
Nome estático 2
Valor 2
••••
Nome estático
20
Valor 20
Statics (R)
Static Name
Value

Elemento Fixed_REC50
(Receitas) Propriedades
Nome estático 1
Valor 1
Nome estático 2
Valor 2
••••
Nome estático
50
Valor 50
Statics (R)
Static Name
Value
Elemento Fixed_RES50
(Recursos) Propriedades
Número
Capacidade ou Horário
ID inteiro ou agendado
Regra de entidade de capacidade
ID do conjunto de estados
Estado inicial
Falha 1
ID de falha 1
Regra 1 da entidade de falha
Falha 2
ID de falha 2
Regra 2 da entidade de falha
••••
Falha 50
ID de falha 50
Regra 50 da entidade de falha
ID de falha
de falha
(R)
Regra de entidade de falha

252
Elemento Fixed_RLN50
(Linhas de relatório) Propriedades
Número
ID do relatório
Formato
Expressão 1
Expressão 2
••••
Expressão 50
Expressões (R)
Expressão

Elemento Fixed_SCH50
(Horários) Propriedades
Capacidade de
recursos 1
Capacidade Duração 1
Capacidade de
recursos 2
Capacidade Duração 2
••••
Capacidade de
recursos 50
Capacidade Duração
50
Capacidade (R)
Capacidade
Capacidade
Capacidade
Elemento Fixed_SEQ3
(Sequências) Propriedades
Número
Estações (R)
ID da estação
Variável 1
Valor 1
Variável 2
Valor 2
Variável 3
Valor 3
Variável de
atribuições (R)
Valor

Elemento Fixed_SEQ20
(Sequências) Propriedades
Número
Estações (R)
ID da estação
Variável 1
Valor 1
Variável 2
Valor 2
••••
Variável 20
Valor 20
Variável de
atribuições (R)
Valor
Elemento Fixed_SEQ40
(Sequências) Propriedades
Número
Estações (R)
ID da estação
Variável 1
Valor 1
Variável 2
Valor 2
••••
Variável 40
Valor 40
Variável de
atribuições (R)
Valor

Elemento Fixed_SEQ50
(Sequências) Propriedades
Número
Estações (R)
ID da estação
Variável 1
Valor 1
Variável 2
Valor 2
••••
Variável 50
Valor 50
Variável de
atribuições (R)
Valor
Elemento Fixed_SEQ100
(Sequências) Propriedades
Número
Estações (R)
ID da estação
Variável 1
Valor 1
Variável 2
Valor 2
••••
Variável 100
Valor 100
Valor variável
das
atribuições
(R)

Elemento Fixed_SEQ250
(Sequências) Propriedades
Número
Estações (R)
ID da estação
Variável 1
Valor 1
Variável 2
Valor 2
••••
Variável 250
Valor 250
Valor variável
das
atribuições
(R)
Elemento Fixed_SET50
(Conjuntos) Propriedad
es
Membro 1
Membro 2
••••
Membro 50
Membros (R)
Membro

Elemento Fixed_STA50
(Estados Unidos) Propriedades
Número
Nome do Estado 1
Stateset Type 1
Nome do Estado 2
Stateset Type 2
••••
Nome do estado 50
Stateset Type 50
Estados (R)
Nome do
Estado
Stateset Tipo
Elemento Fixed_TAB50
(Tabelas) Propriedades
Número
Baixo valor
Incremento fixo
Valor dependente 1
Valor dependente 2
••••
Valor dependente 50
Valores dependentes
(R) Valor
dependente

Elemento Fixed_TRA50
(Transportadores) Propriedades
Número
Número de unidades
Tipo de Mapa do Sistema
ID do mapa
Ao controle
Velocidade
Aceleração
Desaceleração
Velocidade de giro
Posição inicial 1
ID da posição 1
Zona 1
Status inicial 1
Tamanho do
veículo 1
Elemento Fixed_TRA50
(transportadores)

Propriedades
Tamanho Inteiro 1
Posição inicial 2
ID da posição 2
Zona 2
Status inicial 2
Tamanho do veículo 2
Tamanho Inteiro 2
••••
Posição inicial 50
Identificação da posição 50
Zona 50
Status inicial 50
Tamanho do veículo 50
Tamanho Inteiro 50
Dados da
unidade (R)
Posição inicial
Posição ID
Zona
Status
inicial
Tamanho do
 Elemento Fixed_VAR2R
(Variáveis) Propriedades
Número
Índice de matriz 1-D
Índice de matriz 2D
Opção clara
Tipo de categoria
Tipo de categoria de resposta
Tipo de dados
Valores iniciais
(R) Valor 1
Valor 2
Uso
Descrição

Elemento Fixed_VAR10
(Variáveis) Propriedades
Número
Índice de matriz 1-D
Índice de matriz 2D
Opção clara
Tipo de categoria
Tipo de categoria de resposta
Tipo de dados
Valor 1
Valor 2
••••
Valor 10

260
Elemento Fixed_VAR10
(Variáveis) Propriedades
Valores iniciais
(R) Valor
Uso
Descrição

Elemento
Fixed_VAR10R Propriedades
(Variáveis)
Número
Índice de matriz 1-D
Índice de matriz 2D
Opção clara
Tipo de categoria
Tipo de categoria de resposta
Tipo de dados
Valores iniciais
(R) Valor 1
Valor 2
Valor 10

Uso
Descrição
Elemento Fixed_VAR50
(Variáveis) Propriedades
Número
Índice de matriz 1-D
Índice de matriz 2D
Opção clara
Tipo de categoria
Tipo de categoria de resposta
Tipo de dados
Valor 1
Valor 2
••••
Valor 50
Valores iniciais
(R) Valor
Uso
Descrição

262
Elemento Fixed_VAR200
(Variáveis) Propriedades
Número
Índice de matriz 1-D
Índice de matriz 2D
Opção clara
Tipo de categoria
Tipo de categoria de resposta
Tipo de dados
Valor 1
Valor 2
••••
Valor 200
Valores iniciais
(R) Valor
Uso
Descrição
Tipos de dados
Conforme descrito no capítulo "A janela de design da caixa de diálogo", existem
tipos de dados SIMAN disponíveis. Na maioria dos casos, esses tipos de dados são
derivados das entradas de campo válidas dos módulos nos painéis Blocks and
Elements. Consulte a Ajuda para obter mais informações sobre um bloco ou
elemento específico e seus valores de campo válidos.

Definições de tipo de dados

A seguir, é apresentada uma lista dos tipos de dados SIMAN disponíveis. O Nome do
tipo de dados refere-se ao nome do tipo de dados, conforme exibido na entrada da
lista suspensa da propriedade Tipo de dados na janela de design da caixa de diálogo.
Valores são os valores permitidos que um modelador pode inserir. Se esses valores
forem uma sequência ou pontuação de texto literal, eles serão colocados entre aspas
duplas. Se o valor for outro tipo de dados (padrão ou SIMAN), o valor não terá aspas
duplas. Tipos de controle permitidos especifica quais tipos de controle são permitidos
com o tipo de dados.

Nome do tipo de dados AccmLength

Valores AttrID, real

Nome do tipo de dados ActivityAreaLevel

Valores Inteiro

Nome do tipo de dados AllorSpecific

Valores "Todos", "Específico"

Nome do tipo de dados Tempo de chegada

Valores “Hora”, “Primeiro”, “Último”,
“Aquecimento”, “Todos”, “Tecla”,
“Mensagem”

Nome do tipo de dados ArrivalType

Valores “Estação”, “Fila”, “Bloquear”, “Evento”
Nome do tipo de dados AttrID
Valores IdOrInt, SymbolName "(" Inteiro ")", SymbolName
"(" Inteiro "," Inteiro ")", "A (" Inteiro ")"

Nome do tipo de dados BasicTimeUnit

Valores "Segundos", "Minutos", "Horas", "Dias"

Nome do tipo de dados Capacidade

Valores "Capacidade", "Programação"

Nome do tipo de dados ConsOrRange

Valores "Constante", "Alcance"

Nome do tipo de dados ConvType

Valores "Acumulando", "Não Acumulando"

Nome do tipo de dados CountInitOpt

Valores "Replicar", Sim ou Não

Nome do tipo de dados CrossDir

Valores "Positivo", "Negativo", "Qualquer um"

Nome do tipo de dados CrossDirPosNeg

Valores "Positivo negativo"
Nome do tipo de dados Encontro
Valores Encontro

Nome do tipo de dados Data hora

Valores Data hora

Nome do tipo de dados Dia

Valores "11", "12", "13", "14", "15", "16", "17", "18", "19",
"20", "21", "22", "23", "24", "25", "26", "27", "28",
"29", "30", "31", MD1

Nome do tipo de dados DistExp

Valores “EXPO (Média)”, “NORM (Média, StdDev)”,
"TRIA (Mín., Modo, Máx.)", UNIF (Mín.
Máx.) "," ERLA (ExpoMean, k) "," GAMM
(Beta, Alpha) "," JOHN (G, D, L, X) ",
"LOGN (LogMean, LogStd)", "POIS
(Média)", "WEIB (Beta, Alfa)",
“CONT (P1, V1, ...)”, “DISC (P1, V1, ...)”,
Expressão

Nome do tipo de dados Ativado desativado

Valores "Ativado desativado"

Nome do tipo de dados EndOpt

Valores "Erro", "Descarte", "Rebobinar", "Ignorar"
Nome do tipo de dados EntRule
Valores "Preempt", "Ignorar", "Aguardar"

Nome do tipo de dados Tipo de evento

Valores "Usuário", "VBA", "ActiveX"

Nome do tipo de dados FailType

Valores "Contagem", "Tempo"

Nome do tipo de dados Fracasso

Valores "Fracasso"

Nome do tipo de dados FileAccType

Valores “Sequencial”, “Direto”, “Usuário”

Nome do tipo de dados Formato de arquivo

Valores AnyCharacters

Nome do tipo de dados Nome do arquivo

Valores AnyCharacters

Nome do tipo de dados FileStructure

Valores “Não formatado”, “Formato livre”, “Arquivo
WKS”, FileFormat
Nome do tipo de dados FlowAllocation
Valores “ValueAdded”, “NonValueAdded”, “Wait”,
“Transfer”, “Other”

Nome do tipo de dados FlowType

Valores "Adicionar", "Transferir", "Remover"

Nome do tipo de dados FormatType

Valores "Duração", "Calendário"

Nome do tipo de dados FreqExp

Valores "Valor", "Estado"

Nome do tipo de dados GlobalPriority

Valores "QTIME", "LVF", "HVF"

Nome do tipo de dados IdOrInt

Valores SymbolName, Inteiro

Nome do tipo de dados IdOrIntOrRange

Valores SymbolName, Inteiro “-” Inteiro, Inteiro,
SymbolName “-” SymbolName

Nome do tipo de dados IdOrIntOrReal

Valores SymbolName, Inteiro, Real
Nome do tipo de dados IdOrRealorKey
Valores SymbolName, Real, "INFINITE"

Nome do tipo de dados InitOpt

Valores "Hold", "Rewind", "Close"

Nome do tipo de dados InitVar

Valores "J", "M", "NS", "IS", "X" "(" Inteiro ")"

Nome do tipo de dados LinkType

Valores "Unidirecional", "Bidirecional", "Esporão"

Nome do tipo de dados Localização

Valores “Estação”, “Interseção”, “Link”

Nome do tipo de dados LSR

Valores “FCFS”, “LCFS”, “Mais próximo”, “Mais
distante”, “LVF”, “HVF”

Nome do tipo de dados MD1

Valores "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "01",
"02", "03", "04", "05", "06", "07", "08", "09"

Nome do tipo de dados Método

Valores "RKF", "Euler", "Usuário"
 Nome do tipo de dados Mês
Valores "11", "12", "13", "14", "15", "16", "17", "18", "19",
"20", "21", "22", "23", "24", "25", "26", "27", "28",
"29", "30", "31", MD1

Nome do tipo de dados NonNegativeReal

Valores Real Não Negativo

Nome do tipo de dados DataNonNegativeRealorSymbol

Valores Real não negativo, SymbolName

Nome do tipo de dados NonNegativeRealSymbolName

Valores Real não negativo, SymbolName, "NONE"

Nome do tipo de dados PositiveInteger

Valores Número inteiro positivo (valores opcionais mín. E
máx.)

Nome do tipo de dados PositiveReal

Valores Real positivo

Nome do tipo de dados PreemptDest

Valores Etiqueta, "STO" "(" IdOrInt ")"

Nome do tipo de dados QBlock

Valores Rótulo, "COMPARTILHADO"

270
Nome do tipo de dados QSR
Valores “CYC”, “RAN”, “POR”, “LRC”, “SRC”, “LNQ”,
"SNQ", "UR" "(" IdOrInt ")", "ER" "(" IdOrInt ")"

Nome do tipo de dados QuotedString

Valores String entre aspas

Nome do tipo de dados RangeIndex

Valores Inteiro, Inteiro “..” Inteiro

Nome do tipo de dados RankingCrit

Valores "FIFO", "LIFO", "LVF", "HVF"

Nome do tipo de dados RealorInfinite

Valores Real, "infinito"

Nome do tipo de dados RealorSymbolName

Valores Real, SymbolName

Nome do tipo de dados RegulatorTimeUnit

Valores "Por segundo", "Por hora", "Por minuto", "Por dia"

Nome do tipo de dados RepLengthTimeUnit

Valores "Horas", "Dias", "Semanas"
Nome do tipo de dados ResourceAction
Valores "Espera", "Espera até"

Nome do tipo de dados ResourceorSet

Valores "Recurso", "Definir"

Nome do tipo de dados RSR

Valores “CYC”, “RAN”, “POR”, “LRC”, “SRC”, “LNB”,
"SNB", "UR" "(" IdOrInt ")", "ER" "(" IdOrInt ")"

Nome do tipo de dados Tipo de recurso

Valores "Estacionário", "Posicional", "Distância", "Rede"

Nome do tipo de dados RestrColumn

Valores "Excluir incluir"

Nome do tipo de dados Regra

Valores “CYC”, “RAN”, “POR”, “LDS”, “SDS”, “LRC”,
"SRC", "LNQ", "SNQ", "LNB", "SNB", "UR",
"ER", "MIN", "MAX"

Nome do tipo de dados SaveCrit

Valores "Primeiro", "Último", "Produto", "Soma"

Nome do tipo de dados SeedInitOpt

Valores YesOrNo, "Comum", "Antitético"

272
Nome do tipo de dados SensorLocationType
Valores “Nível Específico”, “Capacidade Percentual”

Nome do tipo de dados Gravidade

Valores "Fatal", "Aviso", "Não"

Nome do tipo de dados SignedInteger

Valores Inteiro assinado (mínimo opcional, máximo de
valores)

Nome do tipo de dados Ordenar

Valores "Ascendente", "Descendente", "Não classificado"

Nome do tipo de dados StateSetType

Valores "Inativo", "Ocupado", "Inativo", "Falha", IdOrInt

Nome do tipo de dados Status

Valores "Ativo inativo"

Nome do tipo de dados SystemMap

Valores "Distância", "Rede"

Nome do tipo de dados Tempo

Valores Tempo

Nome do tipo de dados TSR

Valores "CYC", "RAN", "POR", "LDS", "SDS", "UR", "ER"
Nome do tipo de dados UnitTimeUnit
Valores "Segundos por unidade", "Minutos por unidade",
"Horas por unidade", "Dias por unidade"

Nome do tipo de dados VehicleSize

Valores "Comprimento", "Zona"

Nome do tipo de dados Ano

Valores Inteiro

Nome do tipo de dados ZoneControl

Valores "Iniciar", "Final", Inteiro
Tipos de dados do ponto de conexão e
blocos SIMAN
Tipos de pontos de entrada ou saída
Existem seis tipos diferentes de pontos de entrada e seis tipos diferentes de pontos
de saída, conforme observado abaixo.

Tipos de entrada Tipos de saída

Padrão Padrão
Fila Fila
Aproveitar PickQ
Segure o Tipo A QPick
Segure o Tipo B Selecione
Segure o tipo C Balk

DESCRIÇÕES
Os três tipos de entrada diferentes (reter os tipos A, B e C) são usados para distinguir
os módulos que podem se conectar a um módulo QPick (Access, Request, etc.) e os
que não podem (Capture, Group). O Tipo de espera B é usado quando um bloco de
fila é necessário.
Um tipo de entrada Apreender é necessário para o tipo de saída Selecionar, pois
apenas um módulo Apreender pode seguir um módulo Selecionar.
VALIDAÇÃO DA LIGAÇÃO

Tipo de saída Tipo de entrada

Padrão Padrão, Fila, Apreender, Tipo de espera A, Tipo de espera C
Fila Apreender, Segure o Tipo A, Segure o Tipo B, Segure, Tipo C
PickQ Fila
QPick Apreender, Segure o Tipo A, Segure o Tipo B
Selecione Aproveitar

TIPOS DE CONEXÃO EM MÓDULOS SIMAN

Quadra Conexão Tipo

Acesso Tipo de retenção UMA
distribuir Tipo de retenção UMA
Capturar Tipo de retenção C
Combinar Tipo de retenção C
Grupo Tipo de retenção C
PickQ PickQ (no rótulo da fila), Padrão (no balk rótulo)
Preempt Tipo de retenção UMA
Continuar Tipo de retenção C
QPick QPick (no próximo rótulo oculto), PickQ (na fila rótulo)
Fila Fila (ponto de entrada), Fila (ponto de saída no oculto próximo)
rótulo)
Solicitação Tipo de retenção UMA
Varredura Tipo de retenção C
Aproveitar Aproveitar
Selecione Segure o Tipo A, Selecione
Esperar Tipo de retenção C
C Criando arquivos de ajuda online
O Arena fornece aos desenvolvedores de modelos uma interface de ajuda que permite
que os designers associem arquivos de ajuda online aos seus modelos, fornecendo aos
usuários de modelos instruções detalhadas sobre o uso de vários módulos e suas
opções.
Aqui está um exemplo de como a interface de ajuda do modelo funciona. Vamos
supor que você criou um modelo chamado Sample.tpl que contém um módulo
chamado Server. Vamos supor também que a caixa de diálogo principal do módulo
Servidor seja assim:

Figura C.1 Caixa de diálogo principal do módulo Servidor

O grupo de repetição e as caixas de diálogo secundárias (nomes e opções do

servidor) são assim:

Figura C.2 Grupo de repetição de nomes de servidor Figura C.3 Opções Caixa de
diálogo secundária

277
ARENA TEMPLATE DEVELOPER’S GUIDE

Quando você gera o arquivo Sample.tpo, o Arena grava um arquivo de interface de

ajuda chamado
Sample.HH que se parece com isso:
Ajuda automatizada: * .HH
#define TemplateContents4293984255
#define Server4294443008
#define Server_0
#define Server_Server_Names524288
#define Server_Server_Name1048576
#define Server_Quantity1572864
#define Server_Process_Time2097152
#define Server_Options2621440
#define Server_Cost3145728
A coluna da esquerda (por exemplo, #define TemplateContents) exibe o ID do
contexto da Ajuda que será usado pela Ferramenta de criação de ajuda (por
exemplo, RoboHelp®). A coluna da direita exibe o Número do Contexto da Ajuda
que será referenciado pela Arena. Este arquivo serve como um "mapa" entre sua
Ferramenta de criação de ajuda e a Arena.
A primeira entrada para o arquivo .HH de cada modelo contém a entrada #define
TemplateContents. Esse ID de contexto permite que os desenvolvedores de modelos
tenham um tópico do Sumário no arquivo de ajuda do modelo. Quando um painel de
modelo é anexado à Barra de Projeto, o nome do modelo é adicionado à lista de
modelos anexados no menu Ajuda do Arena. Clicar em qualquer uma dessas opções
de menu exibirá automaticamente o tópico de ajuda associado ao ID do contexto do
TemplateContents. Consulte as instruções abaixo para descobrir como associar um ID
de contexto a um tópico de ajuda.
As entradas restantes são determinadas da seguinte maneira: Cada módulo terá uma
entrada correspondente ao nome do módulo (por exemplo, #define Server). Por
padrão, esse ID de contexto é usado quando você clica no botão da barra de
ferramentas Ajuda Sensível ao Contexto (na barra de ferramentas Padrão) e, em
seguida, clique em um botão de módulo na Barra do Projeto. Isso pode ser usado para
exibir uma visão geral dos tipos de usos desse módulo. Esse comportamento pode ser
alterado editando a opção de ajuda do módulo na caixa de diálogo Opções de
modelo.
No Arena, todas as caixas de diálogo do módulo (incluindo caixas de diálogo
secundárias e caixas de diálogo exibidas ao adicionar ou editar itens em grupos
repetidos) contêm um botão Ajuda. Cada botão Ajuda pode exibir o tópico principal
da ajuda para esse módulo ou um tópico exclusivo da ajuda para essa caixa de
diálogo específica do módulo. Por exemplo, o módulo Servidor exibido acima possui
três caixas de diálogo: a caixa de diálogo principal (Servidor) e duas caixas de
ARENA TEMPLATE DEVELOPER’S GUIDE
diálogo secundárias (Grupo de repetição de nomes de servidor e Opções). Cada uma
dessas caixas de diálogo possui um botão Ajuda. O botão Ajuda da caixa de diálogo
Servidor exibirá o principal tópico de ajuda do módulo. A caixa de diálogo Nomes de
servidor pode exibir o tópico principal da ajuda (conforme exibido na caixa de
diálogo Servidor) ou uma ajuda exclusiva
 C • CREATING ONLINE HELP FILES

tópico específico para a caixa de diálogo Nomes de Servidor. A caixa de diálogo

Opções pode exibir o tópico principal da ajuda (conforme exibido na caixa de
diálogo Servidor) ou um tópico exclusivo da ajuda específico para a caixa de
diálogo Opções.
Para habilitar ou desabilitar tópicos de ajuda exclusivos para caixas de diálogo
individuais, especifique a propriedade UniqueHelpTopic de um objeto de formulário
de caixa de diálogo como True ou False na janela de design da caixa de diálogo da
definição do módulo. Por padrão, essa propriedade é definida como True para um
formulário de caixa de diálogo. Se você ativar um tópico de ajuda exclusivo para
uma caixa de diálogo específica, mas não conseguir criar um tópico correspondente
em seu arquivo de ajuda, os usuários que pressionarem o botão Ajuda nessa caixa de
diálogo receberão uma mensagem do sistema de Ajuda do Windows® indicando que
o tópico não está disponível. existe no arquivo de ajuda. Portanto, você deve sempre
definir UniqueHelpTopic como True se não pretender criar um tópico de ajuda
específico para a caixa de diálogo.
Da mesma forma, na janela de design da caixa de diálogo da definição do módulo,
cada objeto de formulário da caixa de diálogo inclui uma propriedade
WhatsThisHelp especificada como Verdadeiro ou Falso. Esta opção fornecerá à
caixa de diálogo um ponto de interrogação no canto superior direito da barra de
título, permitindo que o usuário solicite ajuda sobre um operando específico na caixa
de diálogo. Se você ativar esta opção, mas não fornecer um tópico para cada
operando específico no seu arquivo de ajuda, os usuários que clicarem no ponto de
interrogação e depois clicarem em um operando receberão uma mensagem
informando que o tópico não existe. Portanto, você não deve ativar o "O que é isto?"
opção de ajuda se você não pretende criar um tópico de ajuda para cada operando na
caixa de diálogo.
Quando o arquivo da interface de ajuda (.HH) é gerado junto com o arquivo .tpo, os
IDs de contexto são gravados para cada caixa de diálogo de acordo com as seguintes
regras: o ID de contexto da caixa de diálogo principal é criado anexando um
sublinhado (_) ao nome do módulo, por exemplo, Server_. Os IDs de contexto para
todas as outras caixas de diálogo são criados anexando o nome da caixa de diálogo
ao nome do módulo, separados por sublinhados; espaços incorporados na caixa de
diálogo e nomes de grupos repetidos são convertidos em sublinhados. Por exemplo,
a caixa de diálogo Server Names geraria um ID de contexto de
Server_Server_Names. O ID de contexto da caixa de diálogo Opções seria
Server_Options.
IDs de contexto para "O que é isto?" a ajuda é criada para cada operando anexando
o nome do operando ao nome da caixa de diálogo com um sublinhado. Por
exemplo, a caixa de diálogo Server Names geraria IDs de contexto
Server_Server_TimeName e Server_Quantity para os operandos Server Name and
Quantity na caixa de diálogo Server Names.
Para usar o arquivo da interface de ajuda gerado acima, você precisa primeiro usar sua
Ferramenta de Criação de Ajuda para criar informações de ajuda na forma de
"tópicos". Em seguida, informe à Ferramenta de criação de ajuda que você possui uma
interface de ajuda ou um arquivo "mapa" (por exemplo,
ARENA TEMPLATE DEVELOPER’S GUIDE

Sample.HH) Para fazer isso no RoboHelp, você precisa adicionar o arquivo à

lista de “arquivos de mapa” para o projeto, seguindo o procedimento descrito
abaixo:
1. No menu Project, escolha instalação.
2. Clique na guia Avançado. Sob o título Seção de instalação, realce o item
(Mapa) / Incluir arquivos e clique no cabeçalho Seção de instalação.
3. Escolha o arquivo da interface de ajuda fornecido pelo Arena (por exemplo,
Sample.HH) na lista e clique em Adicionar.
4. Clique em OK várias vezes até fechar todas as caixas de diálogo e retornar ao
documento de ajuda.
Em seguida, você precisa associar os tópicos de ajuda individuais em seu documento
de ajuda aos IDs de contexto contidos no arquivo da interface da ajuda. Para fazer
isso, você deve editar cada tópico da ajuda e localizar o campo Sequência de
Contexto (pode ser necessário clicar no botão Avançado para abrir esta seção da
caixa de diálogo). Clique no botão Escolher para abrir a caixa de diálogo Escolher
sequência de contexto fornecida pela equipe de desenvolvimento. Verifique se o
arquivo da interface de ajuda fornecido pelo Arena está destacado no campo Arquivo
de mapa do projeto. Em seguida, selecione o ID do contexto apropriado na lista
Identificador Simbólico (por exemplo, se você estivesse editando o tópico de ajuda
principal do módulo, escolheria o ID do contexto do Servidor). Clique em OK até
fechar todas as caixas de diálogo e voltar ao documento de ajuda. O tópico agora está
associado ao ID do contexto.
Para associar o ID do contexto TemplateContents ao seu Índice para o modelo,
você deve fazer o seguinte:
1. No menu Project, escolha instalação.
2. Clique no botão Conteúdo.
3. Escolha o ID do contexto de TemplateContents na lista de Strings de Contexto.
4. Clique em OK várias vezes até fechar todas as caixas de diálogo e retornar ao
documento de ajuda.
Na próxima vez que você criar o arquivo de ajuda, ele incorporará os Números de
Contexto da Ajuda apropriados (os valores na coluna direita do arquivo .HH) no
arquivo .hlp. O arquivo de ajuda deve ter o mesmo nome que o arquivo de modelo.
Por exemplo, Sample.tpo procurará um arquivo chamado Sample.hlp.

280
Índice

UMA Barra de ferramentas Design da caixa de

diálogo 110
Teclas do acelerador 109 Painel Grade de propriedades de design
Processo Avançado 2 185 83

Painel de transferência avançada

2 185 Objeto de animação

exibir na visualização do
usuário 170 na janela
lógica 115
Modelo de arena
185 Atribuir módulo

45 Criação

automática 75, 96

B
Caractere de citação de volta
usar para referenciar operando 117
Painel Processo básico 2 185

C
Alterações nas instâncias 75
Caixas de seleção
opções de personalização 147
acesso especial para referências na
janela lógica 123
Prancheta 75, 113, 116, 171, 182
Compatibilidade do módulo existente
instâncias 75
Módulo de atribuição condicional 159
Informações de Contato 5
Criando arquivos de ajuda online
277 Centro de Suporte ao

Cliente 4

D
Propriedade
DataType
SIMAN 102
padrão 101
Decidir módulo 44
Definindo lógica de modelagem
40. Módulo de atraso 48.
Janela Design de Diálogo 33
Grade de propriedades de
design83 objetos de
formulário de diálogo 79
operandos ocultos 79
Operand Explorer 78
objetos operandos 79
repetir objetos de grupo
79 Caixa de ferramentas

80

Caixa de ferramentas
controla a
CheckBox 81
Caixa combo 81
DatePicker 81
DateTimePicker 81
DialogButton 81
FilePicker 81
GroupBox 81
HiddenOperand81
Linha 81
RadioButtonGroup 81
RepeatGroupDialog 81
RepeatGroupTable 81
Texto81
Caixa de texto 81
TimePicker 81
Botão Exibir caixa de diálogo 78
Formulário de diálogo 82
organizando controles 83
disposição 39.
controles de
travamento 83
abertura 82
redimensionando 83
Conexão direta 125 na
lógica do módulo 126
Elemento Distâncias
206

Convenções de
documentos 3 Conjunto
de documentação 3
Desenhar objeto
camada oculta / visível
170 na visualização do

usuário 170
 INDEX

E J
Elemento 183 Propriedade InUserView 103
elementos de dados 183
definir versus opção de referência eu
193 definindo através da hierarquia

186, 190 definindo via elemento Carregando um arquivo da biblioteca

operando 186 listas 186, 188
sublista 189, 192 tipos
especiais
comprimento fixo 204
escondido 204
do painel de modelos (.tpl) 66.
Janela lógica
conectando interruptores 153
instâncias do módulo de conexão
148 processos de decomposição

invertido 206 111 dicas de design 214

liga elementos 202 Painel interruptores de separação 153

Elementos 185 diferenças com a janela do modelo 113
entrada 94 módulo oculto (utlarena.tpo) e
Ponto de comuta 157
entrada várias conexões e comutadores 148
referência de operando na janela lógica abertura 112
127 validação / referência de operando pontos de saída repetidos e
95 operandos 37. conexão única 149
interruptores conectados regras e diretrizes 161
167 objeto de comutadores nas instâncias do
visualização do usuário módulo 124
166 verificando a lógica em relação aos
Erros / avisos 67 comutadores 155 Propriedade
revendo 68 LogicProperties 92
Ponto de saída repetir grupos 104
operando 37.
validação / referência de operando 95 M
Repetivel 136 Janela modelo
interruptores conectados diferenças com a janela lógica113 Módulo
167 objeto de
96
visualização do usuário lidar com 163, 165
166
processo de construção da lógica
41.
F
Campo
usar no capítulo Janela repetidor 139
Lógica 116


Criação de arquivo de ajuda 277 Arquivo de

interface de ajuda 279 Operandos ocultos 79
G
Imagens globais 55

H
Socorro
3

282
 INDEX
opção
requerida
73

tipos de
fluxo de
entidade
125

Definição do
módulo
mudanças e
instâncias existentes
75 copiando 75

e
x
c
l
u
i
n
d
o

6
6
.
referência
s de
operando
116
renomean
do 66.
Janela de
definição
de
módulo
65

abertura
67

Alça do
módulo 165

283
Instância do módulo e
usar no modelo ou janela lógica l
112 Tutorial de criação de módulo e
29 m
Atribuir módulo 45 e
Decidir módulo 44 n
Módulo de atraso 48. t
Módulo de processo 45 o
Módulo de fila 42.
Elemento Filas 50. 

Módulo de liberação 9
48. Módulo de 3
apreensão 42. Elemento
Variáveis 50. p
o
N n
t
Propriedade de nome
o
91 repetir grupos

103
d
Elemento NetworkLink 206
e
Número de saídas alternativas 140
e
O n
Ajuda online 3 t
Abrindo uma janela de definição de r
módulo 67 Abrindo uma nova biblioteca a
de painéis de modelos (.tpl) d
Arquivo 65 a
Operando
valor padrão 117, 199 

dicas de design 211 9

exibir na visualização do usuário 4
167 operando repetível 169

elemento 190 p
propriedade 194 o
definindo elemento e propriedade n
usando operando oculto 199 t
grupo de repetição o
195 referências a 114

alternar várias referências com o conjunto d

fornecido 120 e
relatório de operando de arquivo da
biblioteca do painel de modelos s
(.tpl) 68 a
referência de valor na definição do í
comutador 177 Operandos d
básico 92 a
94

escondido 103
propriedade 93
funções especiais 98
especificando a propriedade DataType
101 especificando a propriedade

InUserView 103 especificando o

LogicProperties
propriedade 92
especificando a propriedade Name 91
especificando o SwitchName
propriedade 102
especificando a propriedade Value 97
Operandos, usando 91

P
Ícone do painel 181
dicas de design
213

tamanho e exibição no painel de modelos

73, 182

Janela de ícone do painel 181

tutorial 56.
Módulo de processo 45
Barra de Projetos 9 23, 58, 72 73
Propriedade 183, 187
liga propriedades 203

Q
Módulo de fila 42.
Elemento Filas 50.

R
Opções de personalização do
grupo de botões de opção
147

acesso especial para referências na

janela lógica 123
Operandos de referência
objetos de animação na visualização do
usuário 170 combinando repetição e
não repetição
referências 136
concatenando texto e referência 118
contendo várias referências 119
operandos do ponto de entrada 127
na definição do comutador 177
várias referências ao mesmo operando 122
ponto de saída repetido 138
operandos repetidos 131
Módulo de liberação 48. r
Repetir grupo 103 e
mudar de uso 180 l
Repetir objetos de grupo a
79 Repetir grupos t
acessando o número de tuplas e o número ó
do tu-107 r
combinando valores repetidos de i
operando em um único valor107 o
profundidade de definição e regras de
referência 105 regras de referência 129 

especificando a propriedade 6
LogicProperties 104 8
especificando a propriedade Name 103
Lógica repetível 139
Módulo repetível 139
Analisar erros 68

S
Modelos de amostra 3
Elemento de segmentos
206 Módulo de

apreensão 42.
Elemento Sets 206
Modelo SIMAN 185
Lógica de simulação e design de módulos
111 Biblioteca Smarts 3

Transferência de estação
125

na lógica do módulo
125 Estatisticas

dicas para projetar no módulo215

Submodelo 112
Interruptor 175
e elemento 202 e
propriedade 203
anexado ao objeto de animação
da visualização do
usuário171
definindo 176
definição 71, 176, 177
comparação de operando com valor
178 na instância do módulo da janela

lógica 124 nome 177

regras sobre definições 179 opção de
arquivo da biblioteca do painel de
modelos (.tpl)
 usar na janela lógica 152
usar nas janelas de definição de módulo 176

T
Suporte técnico 4 Modelo
documentação 214
Barra de ferramentas de desenvolvimento de modelos 33
Painel Modelo 65
alterando o nome de exibição 72 criando nova
janela 32. destacando 76
tamanho e exibição do ícone 73 privado
72

Alterações no arquivo da biblioteca do painel de

modelos (.tpl) e módulo existente
instâncias 75
verificação de erros / avisos 67 Arquivo de objeto do
painel de modelo (.tpo)
mudanças e instâncias existentes 75 gerar .tpo na janela do
modelo 67, 71 fornecendo ao modelador 71
Regras relativas à Ligação a Janelas Lógicas 115
Fechamento da janela do modelo
66.

excluindo um módulo 66.

gerando o arquivo de objeto do painel de modelo (.tpo) 71
renomeando um módulo 66. relatório 68
opções de modelo 71 versão 71
Caixa de ferramentas, usando
Controle CheckBox 87 Controle ComboBox 85
Controle DatePicker 89 Controle
DateTimePicker 88 Controle DialogButton 87
Controle FilePicker 90 Controle GroupBox 85
HiddenOperand control 91 Controle de linha 85
Controle RadioButtonGroup 86 Controle
RepeatGroupDialog 87
 Controle RepeatGroupTable
88 Controle de texto 84
Controle TextBox 85
os controles 83
Controle TimePicker
90
Vestí
gio
dicas de design para uso na
definição de módulo
215
Rastrear nas definições do
módulo160 Cursos de
treinamento 5
Tuple
valor da troca 179
W
Propriedade Value 97
Elemento Variáveis 50.
Suporte na Web 4
O que é isso? Socorro279
IDs de contexto 279
Unidades mundiais
163 Visualização do
usuário 163
dicas de design 213
concepção 53
modificações pelo modelador 164
Janela de visualização do usuário 163
tutorial 53 Arquivo
Utlarena.tpo 156
módulo de atribuição condicional 159
módulo oculto 157