Templete Developer S Guide - En.pt

®
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
Eu
O que há de novo?
O seguinte está incluído na Arena 15.1:
Suporte do Windows 10
A Arena agora oferecerá suporte oficial ao sistema operacional Windows 10. O Arena não oferece mais suporte
oficial ao sistema operacional Windows Vista.
Nova animação do placar
Uma nova tela de status do placar foi adicionada à barra de ferramentas "Animar". Esse controle de objeto de
animação pode ser usado para exibir variáveis e expressões de modelo semelhantes a uma planilha. O conteúdo
da célula pode exibir texto descritivo ou o valor atual de uma variável ou expressão do modelo.
Um novo smart que ilustra a criação de uma animação Socreboard foi adicionado. Para acessar este arquivo da
Arena, use o menu Arquivo, selecione "Procurar SMARTS ...". E selecione o modelo localizado na pasta
Animação: Animation Arena Scoreboard.doe
Novos Módulos
·Módulo de coleta
O módulo GATHER é usado quando uma entidade requer uma ou mais unidades de qualquer um ou
mais membros de um conjunto de recursos de recursos intercambiáveis. Diferentemente do
módulo SEIZE, GATHER permite que uma entidade aproveite unidades de vários membros de
um conjunto de recursos especificado. SEIZE, ao especificar SELECT a partir de um conjunto,
pode capturar apenas as unidades especificadas de um membro do conjunto especificado.
Um novo smart que ilustra as diferenças entre o módulo Gather e o módulo Seize foi adicionado.
Para acessar este arquivo da Arena, use o menu Arquivo, selecione "Procurar SMARTS ...". E
selecione o modelo localizado na pasta Advanced Concept: Advanced Concept GatherVSeize.doe
·Módulo de dispersão
O módulo DISPERSE é usado quando uma entidade está pronta para liberar algumas ou todas as
unidades dos membros do conjunto de recursos que foram apreendidas usando um módulo
GATHER.
Um novo inteligente que descreve o uso dos novos módulos Gather and Disperse foi adicionado. Para
acessar este arquivo da Arena, use o menu Arquivo, selecione "Procurar SMARTS ...". E
selecione o modelo localizado na pasta Advanced Concept: Advanced Concept
GatherDisperse.doe
Atualizações do módulo
·Set Data Module

O módulo Set foi aprimorado para permitir que o usuário especifique um arquivo de dados e o
conjunto de registros correspondente para utilizar a leitura direta para definir a propriedade de
membros do conjunto. Além disso, o usuário agora pode definir conjuntos de recursos usando
outros conjuntos de recursos.
Um novo smart que ilustra o uso do novo conjunto de recursos de conjuntos foi adicionado. Para
selecione o modelo localizado na pasta Resources: Resources SetHierarchy.doe
Um novo inteligente que descreve o uso do novo recurso de leitura direta foi adicionado. Para
selecione o modelo localizado na pasta Arquivos de Dados Externos: Arquivos de Dados
Externos Define Leitura Direta no Excel.doe
·Módulo de dados de conjunto avançado
O módulo de dados Advanced Set foi aprimorado para permitir que o usuário especifique um arquivo
de dados e o conjunto de registros correspondente para utilizar a leitura direta para definir a
propriedade de membros do conjunto.
·Módulo de dados do transportador
O módulo de dados do transportador foi aprimorado para permitir que o usuário especifique um
arquivo de dados e o conjunto de registros correspondente para utilizar a leitura direta para
especificar as propriedades numéricas dos transportadores.
Um novo smart que ilustra o uso do recurso de leitura direta foi adicionado. Para acessar este
arquivo da Arena, use o menu Arquivo, selecione "Procurar SMARTS ...". E selecione o modelo
localizado na pasta Transportadores: Dados do Transportador DirectRead.doe no Excel
·Módulo de dados por segmento
O módulo de dados do segmento foi aprimorado para permitir que o usuário especifique um arquivo
de dados e o conjunto de registros correspondente para utilizar a leitura direta para especificar
os dados repetíveis das próximas estações de um segmento.
Um novo inteligente que descreve o uso do recurso de leitura direta foi adicionado. Para acessar este
localizado na pasta Transportadores: Dados do Transport DirectRead no Excel.doe
·Módulo de dados de programação
O módulo de dados de agendamento foi aprimorado para permitir que o usuário especifique um
arquivo de dados e o conjunto de registros correspondente para utilizar a leitura direta para
especificar os dados de durações repetíveis dos agendamentos.
Um novo inteligente que descreve o uso do recurso de leitura direta foi adicionado. Para acessar este
localizado na pasta External Data Files:Arquivos de dados externos Leitura Direta do Excel
para Schedule Data.doe
Nova funcionalidade
O módulo ReadWrite foi modificado para incluir duas opções de formato adicionais. Decimais reais (% f) e
notação científica real (% e) foram adicionados às opções existentes de real (% g), número inteiro (% i) e
sequência (% s).
Uma nova função denominada "ExcelDatetoBaseTime" foi adicionada. Esta função converterá o número de série
da data do Excel em unidades de tempo base emArena.Um novo inteligente que descreve o uso da nova função
foi adicionado. Para acessar este arquivo da Arena, use o menu Arquivo, selecione "Procurar SMARTS ...". E
selecione o modelo localizado na pasta External Data Files:Arquivos de dados externos
ExcelDateToBaseTime function.doe
Duas novas funções de recursos denominadas "LESR" e "LERR" foram adicionadas. A função LESR retornará a
última entidade que apreendeu ou reuniu unidades de um recurso especificado. A função LERR retornará a
última entidade que liberou ou dispersou as unidades de um recurso especificado.
Novos Smarts
Os seguintes modelos de exemplo foram adicionados à biblioteca de arquivos Smarts:
-Chamada lógica de controle Reneging.doe:Modelo de exemplo de Renegação de chamada em

um Call Center.
-Control Logic Outro tipo Schedule.doe: Ilustra o uso de um outro tipo de agendamento.
-Resources Using Statesets.doe: ilustra o uso de um estado e conjunto de estados definidos pelo
usuário para coletar estatísticas de frequência de recursos.
-O processo de fluxo reduz a taxa de fluxo do regulador como drenos do tanque.doe: ilustra como
reduzir a taxa de fluxo de um regulador com base no nível do tanque.
VAtualizações personalizadas do Designer
Suporte para Sketchup 2017
O Visual Designer de 64 bits foi atualizado para oferecer suporte a arquivos .skp mais recentes (SketchUp
2017). O Visual Designer de 32 bits não suporta arquivos .skp mais recentes (SketchUp 2017). O Visual
Designer de 32 bits continuará a oferecer suporte ao Sketchup 2016.
Observe que os arquivos do Visual Designer criados com o Visual Designer de 64 bits e que contêm um novo
objeto estático do Sketchup 2017 falharão ao carregar o objeto na cena com o Visual Designer de 32 bits.
Vulnerabilidade de segurança
Esta versão corrige uma vulnerabilidade de segurança no Arena. Essa vulnerabilidade pode causar falha no
aplicativo Arena, potencialmente perdendo dados não salvos. Para obter detalhes completos sobre a
vulnerabilidade e atenuações adicionais, consulte o artigo RAid # da base de conhecimento1073588.
Suporte à ferramenta de exportação

A ferramenta 'Exportar estatísticas de resumo para arquivo CSV' foi atualizada para permitir a seleção de
arquivos de banco de dados .accdb Access criados pelo Arena. Esta ferramenta agora está incluída na versão de
64 bits do Arena.
Atualizações do Crystal Report
Uso aprimorado de memória com o Crystal Report. Foi corrigido um problema de vazamento de memória que
causava problemas na memória disponível para o aplicativo Arena.
Itens retirados
À medida que a Arena evolui e como a tecnologia exige, os recursos obsoletos ou pouco
usados serão removidos da Arena. Isso envolve uma avaliação completa de como as alterações
propostas podem afetar nossos clientes e se existem alternativas dentro da Arena. Isso nos
proporcionará maior flexibilidade no processo de desenvolvimento e nos permitirá
desenvolver as melhorias necessárias. Os seguintes itens serão retirados da Arena em
lançamentos atuais e futuros:
Controle ActiveX SymbolFactory
O Arena não oferece mais suporte ao controle ActiveX SymbolFactory. Remova o uso do controle ActiveX
de qualquer modelo antes de migrar seus modelos para o Arena 15.0.
Mecanismo de banco de dados Microsoft JET
O Arena não instala mais o mecanismo Microsoft JET Database. O Arena agora usa o Microsoft Access
Database Engine 2010 para conectividade ao Excel, Access etc. Você precisa atualizar as cadeias de
caracteres do Provedor que atualmente usam o provedor JET. Altere Provider = Microsoft.Jet.OLEDB.4.0
"para" Provider = Microsoft.ACE.OLEDB.12.0 "para conectar-se à fonte de dados necessária.
Suporte do Windows XP
O Arena não será mais suportado na plataforma Windows XP.
Módulo Ações do Painel Comum
O Arena não suportará mais o uso do módulo Actions no painel Common. Remova o uso de todos os
módulos de ações antes de migrar seus modelos para o Arena 15.1.
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
iii
CONTENTS
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
iv
GUIA DO DESENVOLVEDOR DE MODELOS DA ARENA
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
v
CONTEÚDO
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
vi
UMARENA TEMPLATE DEVELOPER"S GUIDE
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
vii
CONTENTS
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
11
11 Bem-vindo
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
viii
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,
convém ver os conceitos apresentados no Capítulo 2.
2
1 • WELCOME
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.
DCONVENÇÕES DO OCUMENTO
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
ARENA TEMPLATE DEVELOPER"S GUIDE
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.
UMAO SUPORTE TÉCNICO DA RENA 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.4
1 • WELCOME
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
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.
Figura 2.1 Visualização do usuário do módulo de processo
7
2 • ARENA TEMPLATE DDESENVOLVIMENTO
OVERVIEW
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.
8
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.
Figura 2.2 Janela de modelo de amostra

10
OVERVIEW
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
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
OVERVIEW
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
11
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

OVERVIEW
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.
14
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.
15
OVERVIEW
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
16
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
17
OVERVIEW
é 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

18
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.
19
OVERVIEW
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.
Figura 2.15 Janela do comutador de amostra
21
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.
20
OVERVIEW
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
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.
22
Hierarquia do 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.
23
OVERVIEW
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
24
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
25
OVERVIEW
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.
26
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
apresentados, você também coloca um
29
3 • MODULE-CONSTRUÇÃO
TUTORIAL
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.
30
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 transferência da
Arena.
32.
3 • MODULE-CONSTRUÇÃO TUTORIAL
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

31
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.
34
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).
PRINTER NAME OPERAND
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
35
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
 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
36.
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.
TTÉCNICO, CHANGEOVER TIME, E PRINT TOPERADORES DO IME
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.
37.
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.
38.
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
39.
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
fundamentalmente as mesmas que as envolvidas na criação de um modelo de
Arena. Para as instruções apresentadas neste
41.
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
40.
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.
43
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
44
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 SIMAN deve ser usado. (Os
interruptores são descritos no “Desenvolvimento de modelos de arena
Visão geral ”e“ Alternar janela ”.)
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. Finalmente, 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 .
45
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.
46.
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
47
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
48.
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
49.
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.
51
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
50.
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 visualizaçã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
53
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.
54
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
55
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.
56.
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.
57
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
58
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
GENERANDO ENTIDADES DE TRABALHO DE IMPRESSÃO —TELE CREATE

MODULE
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
59.
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
PMELHORANDO OS TRABALHOS DE IMPRESSÃO—TELE PMÓDULO RINTER

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.
61
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
60
FTRABALHOS DE IMPRESSÃO INICIADOS—TELE DMÓDULO DE ISPOSE

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).
SPROJETO DE IMULAÇÃO E INFORMAÇÃO DO COMPRIMENTO DA

EXECUÇÃO—TELE RUN > SMENU ETUP
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
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.
62
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.
63.
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.
64
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.
Figura 4.1 Janela Novo modelo

65
4 • TELE TEMPLATE WINDOW
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
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.
66.
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
67
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.
68
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,
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.
OPERAND PRELATÓRIO DE OSIÇÕ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.
69
Figura 4.5 Relatório de exemplo de posições de operando
OPERAND PRELATÓRIO ROMPTS

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.
71
SRELATÓRIO DA BRUXA
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
70
item da barra de menus principal. A caixa de diálogo Opções de modelo é aberta,

Figura 4.7 Caixa de diálogo Opções do modelo
CPENDURANDO O NOME DO VISOR DO 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.
CREATING "PRIVADO" PAINÉIS DE MODELO
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
CPENDURANDO O 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.
CPENDURANDO 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.
EXPORT SOPÇÃO ORT
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
73
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
74
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
75
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.
76
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
5 • TELE DIALOG DESIGN WINDOW
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 esta ação.
78
As funções de forma de caixa de diálogo, operando e objetos de grupo de

repetição são descritas mais abaixo.
DIALOGFOBJETOS ORM
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.
OPERAND OBJETOS
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.
REPEAT GOBJETOS ROUP
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 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.
79
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.
81
Tabela 5.1 Resumo dos controles da caixa de ferramentas

Nome do Descrição
Controle
Texto Usado para exibir uma sequência de texto simples em um
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.
RepeatGroupDialo Usado para permitir que um usuário insira valores para
g vários 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).
80
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
OENFRENTANDO 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.
RDimensionando 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.
UMAControle de 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.
euCONTROLES DE OCK 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.
83
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.
84
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, Òperand1`) 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
85
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.
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.
86
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 as
caixas de seleção para dar ao usuário uma escolha 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.
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,
87
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
88
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.
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.
89
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
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.
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
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
Arquivos do tipo). Digite uma sequência de filtros usando o formato Descrição1 |
Padrão1, Descrição2 | Padrão2 e assim por diante.
91
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 (*. *) | *. *"
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.
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.
90
O nome de um operando pode ser usado (colocando o nome entre aspas, por exemplo,
Òperand1`) 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.
BASIC OPERAND
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
EOPERAÇÃO DO LEMENTO
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, see
Capítulo 10.
POPERAÇÃO DE ROPERTY
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á
93
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.
ENTRYPOINT OPERAND
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.
EXITPOINT OPERAND
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.
94
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.
ENTRY/ EXIT PVALIDAÇÃO E REFERÊNCIA
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 275para 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.
95
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.
UMAUTO-CMÓDULOS DE AVALIAÇÃO
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á.
96
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 maisdetalhes a partir da 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.
COMBINAÇÃO DE 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.
97
SFUNÇÕES REFERENCIAIS ESPECIAIS

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 Descrição
^ Module_ID () ^ 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."
^ Nome_do_Módulo () ^ Retorna o nome da definição do módulo. Por
exemplo, "Criar".
^ Module_Number () ^ Retorna o número da instância do módulo no
modelo. Por exemplo, "5"
^ TIME_TO_BASE_TIME Converte um valor de tempo de unidades
(TimeVal ue, TimeUnits) ^ de tempo em um valor de tempo de
unidades de tempo base (conforme
especificado em Executar> Configuração>
Parâmetros de replicação).
^ RATE_TO_BASE_RATE Converte um valor de taxa de unidades de
(RateValu e, TimeUnits) ^ tempo em um valor de taxa de unidades de
tempo base (conforme especificado em
Executar> Configuração> Parâmetros de
replicação).
^ Line_Number () ^ Retorna o índice nos conjuntos de dados
repetidos do grupo de repetição.
^ Num_Lines (repetir nome do Retorna o número de conjuntos de dados
grupo) ^ 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.
98

^ Nome do analista () ^ Fornece acesso ao nome do analista do projeto,
conforme obtido na página Parâmetros do
projeto.
^ Use_Costing () ^ Fornece acesso à caixa de seleção (Sim,
Não) para ativar e desativar cálculos de
custo para o modelo de simulação,
projeto.
^ Use_Entities () ^ 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.
^ Use_Resources () ^ Fornece acesso à caixa de seleção (Sim,
Não) para ativar e desativar estatísticas de
recursos para o modelo de simulação,
projeto.
^ Use_Tanks () ^ 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.
^ Use_Queues () ^ 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.
^ Use_Transporters () ^ Fornece acesso à caixa de seleção (Sim,
Não) para ativar e desativar as estatísticas
do transportador para o modelo de
Parâmetros do projeto.
^ Use_Conveyors () ^ Fornece acesso à caixa de seleção (Sim,
do transportador para o modelo de
^ Use_Processes () ^ Fornece acesso à caixa de seleção (Sim,
do processo para o modelo de simulação,
projeto.
99

^ Estações_Uso () ^ Fornece acesso à caixa de seleção (Sim,
da estação para o modelo de simulação,
projeto.
^ Use_ActivityAreas () ^ Fornece acesso à caixa de seleção (Sim,
Não) para ativar e desativar estatísticas da
área de atividade para o modelo de
^ Número_de_Replicações () ^ Fornece acesso ao número de replicações para
um projeto, conforme obtido na página
Parâmetros de Replicação.
^ Replication_Length () ^ Fornece acesso ao comprimento da execução da
Parâmetros de replicação.
^ Initialize_System () ^ 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.
^ Initialize_Statistics () ^ Fornece acesso à caixa de seleção (Sim,
Não) para inicializar as estatísticas entre as
replicações de simulação, conforme obtido
^ StartDateTime () ^ Fornece acesso à data e hora de início da
^ Warm_up_Period () ^ Fornece acesso ao período de tempo para o
período de aquecimento, conforme obtido na
página Parâmetros de replicação.
^ Terminating_Condition () ^ 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.
^ Horas_Por Dia () ^ Fornece acesso ao número de horas por
dia simulado, conforme obtido na página
101

^ Base_Time_Units () ^ 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
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.
STIPOS 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.
100
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”.
SIMAN TIPOS DE DADOS
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.
103
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.
BGRUPO ASIC REPEAT
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.
PGRUPO DE REPETIÇÃO DE ROPERTY
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
104
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
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.
105
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
106
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.
107
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
108
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).
109
 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.
111
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 do módulo durante uma execução de simulação podem sofrer 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.
110
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
6 • TELE euOGIC WINDOW
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.
113
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 116descreve 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 175para 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, see “Módulos
repetíveis” na página 139.
114
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.
115
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
116
para usar e colocar o nome entre caracteres de aspas posteriores (`). Nós nos referimos
a isso como
referenciamentoum 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.
117
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
118
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).
COMBINAR 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
119
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.
121
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.
120
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`Àttribute` (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ÚLTIMAS 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.
123
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.
124
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.
STRANSFERÊNCIA DE TAÇÃ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.
125
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.
DTRANSFERÊNCIAS IRECTAS
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).
126
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.
127
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'
128
6 • TELE euOGICWINDOW
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 77para 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

129
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
131
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.
130
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,
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ÚLTIMAS 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.
133
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.
134
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.
135
CREFERÊNCIAS OMBINANTES À REPETIÇÃO E NÃO -REPETIR

OPERANDO
É 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
136
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.
137
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.
138
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.
139
UMARENA TEMPLATEDEVELOPER"S GUIDE
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.
141
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
140
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.
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
143
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.
144
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.
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
145
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.
146
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`Àccess` 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,
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 152para 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
148
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
149
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
151
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.
150
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, selecione o módulo
(clicando em sua alça) e selecione o item de menu Objeto> Alternar> Anexar ou
clique no botão da barra de ferramentas Anexar comutador na barra de ferramentas
Desenvolvimento de modelos. É 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.
153
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.
154
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.
155
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
156
janelas. As seções a seguir descrevem os módulos contidos neste painel de

modelos e ilustram seu uso.
HMÓDULO IDDEN
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.
157
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.
158
TELE CONDITIONAL UMAMÓDULO DE ASSINATURA

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
159
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.)
161
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
160
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.
163
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
7 • TELE vocêSER VIEW WINDOW
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.
165
UMARENA TEMPLATEDEVELOPER"S GUIDE
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.
166
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.
167
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.
168
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.
169
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
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.
171
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.
170
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

173
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.
174
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
8 • TELE SBRUXA WINDOW
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
176
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 Coloque em Definição de Exemplo
Referenciado
Operando Citações de volta (``) `ResName` ==” Machine ”
Valor do operando Aspas duplas (" ") "Estado" <> "Ocupado"
Interruptor - Switch1 &&! Switch2
177
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
Opera
dor Significado Usar Exemplo
lógico
== "é 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 !SwSetupRequired
um valor de
comutador
&& "e" Combine SwCount &&
comparações, `Contador` ==”
exigindo que ambas Individual ”
sejam verdadeiras
|| "ou" Combine SwSetup ||
comparações, SwNewRecipe
exigindo que elas
sejam verdadeiras
> "é melhor que" Compare op ao valor "Número"> "14"
>= "é maior que Compare op ao valor "Peso"> = "100,3"
ou igual a"
< "é menos do que" Compare op ao valor `Time` <" 10,5 "
<= "É menor ou Compare op ao valor `Tabelas` <=” 20 ”
igual a"
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
178
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
179
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).
181
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.
180
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).
183
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 Apre
Capacidade ou Horário ender
Padrão de falha de estados Liber
(ocupado, ocioso e assim ação
por diante) Pree
Custeio e Eficiência mpt
Alter
Transportador Nome Aces
Velocidade so
dos Inici
segmentos ar
de caminho Saíd
Tipo a
de Sair
status
do
taman
ho da
célula
Transportador Nome Alocar
Número de Solicit
unidades Tipo ação
Desaceler de
ação da Movi
aceleraçã menta
o de ção de
velocidad Transp
e orte
Características iniciais Gratuit
da unidade (posição, o
status, tamanho) Ativa
r
parad
a
Fila Nome Pesq
Indicador uisa
Compartilhado de
de Critério de inser
Classificação ção
de
fila
Rem
over
Estação Nome Estaçã
Receita de o de
interseção associada transp
orte de
rota de
transp
orte
184
10 • ELEMENTOS
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
185
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 190e"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
186
10 • ELEMENTOS
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.
187
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
188
10 • ELEMENTOS
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.
189
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.
191
10 • ELEMENTOS
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.
190
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
10 • ELEMENTOS
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.
193
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
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.
194
10 • ELEMENTOS
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
195
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.
196
10 • ELEMENTOS
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.
197
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
198
10 • ELEMENTOS
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.
199
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)
201
10 • ELEMENTOS
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
200
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,
definir o
202
10 • ELEMENTOS
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.
203
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.
204
10 • ELEMENTOS
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
205
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.
206
10 • ELEMENTOS
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).
207
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`Ènd``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.
208
10 • ELEMENTOS
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.
209
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.
211
UMADesign de modelo
Diretrizes
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.
210.
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).
Use a funcionalidade Módulo criado automaticamente para criar automaticamente
módulos de "dados" a partir de módulos "lógicos".
212
A • TEMPLATE DESIGN GUIDELINES
Í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.
213
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.
214
A • TEMPLATE DESIGN GUIDELINES
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.
215
 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).
216
BTabelas
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 PropriedadesNível
da organização Área
de atividade pai
Estatísticas
automáticas Gerar
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
máximo
Tamanho do
lote
217
B • TCAPAZES
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
Tamanho mínimo
do passo Tamanho
máximo do passo
218
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
219
B • TCAPAZES
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
desNome
do número
Arquivo de
saída ID do
relatório
Tipo de
dados
Categoria
ID do
processo
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
221
Elemento DISTANCES Propriedades

Estação (R)
ID da estação inicial
Distância da ID da
estação final
DISTRIBUIÇÕES
Elemento
Propriedad
esNúmero
Dist Índice
Dist1 Dist
Índice2
Valores Dist
(R) Valores
Elemento DSTATS
Proprieda
desNome
do número
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
220
B • TCAPAZES
Elemento DSTATS
Propriedad
esID 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
automáticas
Categoria
Identificador
automático de
estatísticas
Elemento EVENTS
PropriedadesTol
erância de
cruzamento do
valor limite de
direção de
cruzamento
variável
222
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
sNúmero
Nome do
sistema Tipo
de acesso
Acesso
Comprimento
Estrutura
Fim do arquivo
Ação Comentário
Caractere Inicializar
Opção Nome do
Conjunto de
Registros
223
B • TCAPAZES
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
224
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
225
B • TCAPAZES
INTERSECÇÕES
Elemento
Propriedade
sNú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
Comprimento de
cada tipo de link de
zona
Fator de mudança de velocidade
226
Elemento NETWORKS Propriedades

Número
Links (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
227
B • TCAPAZES
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
228
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
identificaçã
o de rede
Intersecções (R) Início ID
de interseção Final ID de
interseção Próximo ID de
interseção
229
B • TCAPAZES
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
relatório
Expressões (R)
Expressão
231
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
230
B • TCAPAZES
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 Propriedades

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
Inicialização do
Valor Inicial
Elemento SEGMENTS Propriedades

Estação de Início
Próximas
estações (R)
Próxima estação
232
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
233
B • TCAPAZES
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
desNúmer
o baixo
valor
Incremento fixo
Valores dependentes
(R) Valor
dependente
Elemento TALLIES
Proprieda
desNúmer
o Arquivo
de saída ID
do relatório
Tipo de
dados
Categoria
ID do
processo
234
Elemento TANKS
Proprieda
desNú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
esParâmetro
de formato
Exec Expr do
número da
tarefa
Elemento TRACE
Propriedades
Horário de
início Condição
de horário de
término
Expressões (R)
Expressão
235
B • TCAPAZES
TRANSPORTADORES
Elemento
PropriedadesN
ú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
236
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
Tempo de leitura
do arquivo de
conjunto de
registros
vinculado
Valores iniciais
(R) Valor
Elementos invertidos
Listados abaixo estão os elementos invertidos e suas propriedades, conforme descrito
no capítulo "Elementos".
Inv_DISTANCES
ID da estação inicial
ID da estação final
Distância
ID do conjunto de distâncias
237
B • TCAPAZES
Inv_LINKS
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
Inv_SEGMENTS
Estação de Início
Próxima estação
comprimento
ID do conjunto de segmentos
Elemento Inv_SETS Propriedades

Nome do conjunto
Inv_STATESETS
Propriedades
Tipo de conjunto de estados
ID do conjunto de estados
238
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 Propriedades
(chegadas)
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)
239
B • TCAPAZES
Elemento
Fixed_ARR50 Propriedades
(chegadas)
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 Propriedades
(atributos)
Número
Índice de matriz 1-D
Índice de matriz 2D
Tipo de dados
241
Elemento Fixed_ATT10R
(Atributos) Propriedades
Valores iniciais
(R) Valor 1
Valor 2
Valor 10
Elemento
Fixed_ATT50 Propriedades
(atributos)
Número
Tipo de dados
Valor 1
Valor 2
Valor
50
Valores
iniciais (R)
Valor
Elemento
Fixed_EXP2R Propriedades
(expressões)
Número
Tipo de dados
Valores de
expressão (R)
Expressão 1
Expressão 2
Uso
Descrição
240
B • TCAPAZES
Elemento
(expressões)
Número
Tipo de dados
Valores de
expressão (R)
Expressão 1
Expressão 2
Expression 3
Usage
Description
Elemento
(expressões)
Número
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
(expressões)
Número
Tipo de dados
Valores de
expressão (R)
Expressão 1
Expressão 2
Expressão
7
Uso
Descrição
Elemento
(expressões)
Número
Tipo de dados
Valores de
expressão (R)
Expressão 1
Expressão 2
Expressão
30
Uso
Descrição
243
B • TCAPAZES
Elemento
Fixed_EXP5 Propriedades
(expressões)
Número
Tipo de dados
Expressão 1
Expressão 2
••••
Expressão 5
Expressões
(R)
Expressão
Uso
Descrição
Elemento
(expressões)
Número
Tipo de dados
Expressão 1
Expressão 2
••••
Expressão 10
Expressões
(R)
Expressão
Uso
Descrição
244
Elemento
(expressões)
Número
Tipo de dados
Valores de
expressão (R)
Expressão 1
Expressão 2
Expressão
10
Uso
Descrição
Elemento
(expressões)
Número
Tipo de dados
Expressão 1
Expressão 2
••••
Expressão 15
Expressões
(R)
Expressão
Uso
Descrição
245
B • TCAPAZES
Elemento
(expressões)
Número
Tipo de dados
Expressão 1
Expressão 2
••••
Expressão 20
Expressões
(R)
Expressão
Uso
Descrição
Elemento
(expressões)
Número
Tipo de dados
Expressão 1
Expressão 2
••••
Expressão 25
Expressões
(R)
Expressão
Uso
Descrição
246
Elemento
(expressões)
Número
Tipo de dados
Expressão 1
Expressão 2
••••
Expressão 50
Expressões
(R)
Expressão
Uso
Descrição
Elemento
Fixed_FRE50 Propriedades
(frequências)
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
247
B • TCAPAZES
Elemento Fixed_FRE50
(Frequências) Propriedades
Valor 2
Alto valor 2
Categoria 2
Categoria Opção 2
••••
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 valor
Elemento
Fixed_LEV10R Propriedades
(níveis)
Número
Valores
iniciais (R)
Valor 1
Valor 2
Valor
10
248
Elemento
Fixed_LEV50 Propriedades
(níveis)
Número
Valor 1
Valor 2
••••
Valor 50
Valores
iniciais (R)
Valor
Elemento
Fixed_PAR50 Propriedades
(Parâmetros)
Número
Valor 1
Valor 2
••••
Valor 50
Valores
iniciais (R)
Valor
249
B • TCAPAZES
Elemento
Fixed_RAT10R Propriedades
(taxas)
Número
Valores
iniciais (R)
Valor 1
Valor 2
Valor
10
Elemento
Fixed_RAT50 Propriedades
(taxas)
Número
Valor 1
Valor 2
••••
Valor 50
Valores
iniciais (R)
Valor
251
Elemento
Fixed_REC20 Propriedades
(Receitas)
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 Propriedades
(Receitas)
Nome estático 1
Valor 1
Nome estático 2
Valor 2
••••
Nome estático 50
Valor 50
Statics (R)
Static
Name
Value
250
B • TCAPAZES
Elemento
Fixed_RES50 Propriedades
(Recursos)
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
••••
Falha 50
ID de falha 50
ID de
falha de
falha
(R)
Regra de entidade de falha
252
Elemento
Fixed_RLN50 Propriedades
(linhas de relatório)
Número
ID do relatório
Formato
Expressão 1
Expressão 2
••••
Expressão 50
Expressões
(R)
Expressão
Elemento
Fixed_SCH50 Propriedades
(programações)
Capacidade de recursos 1
Capacidade Duração 1
••••
Capacidade (R)
Capacidade
Capacidade
Capacidade
Duração
253
B • TCAPAZES
Elemento
Fixed_SEQ3 Propriedades
(sequências)
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
(sequências)
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
254
Elemento
(sequências)
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
(sequências)
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
255
B • TCAPAZES
Elemento
(Sequências)
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
(sequências)
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)
256
Elemento
Fixed_SET50 Propriedades
(conjuntos)
Membro 1
Membro 2
••••
Membro 50
Membros
(R)
Membro
Elemento
Fixed_STA50 Propriedades
(conjuntos de
estados)
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
257
B • TCAPAZES
Elemento
Fixed_TAB50 Propriedades
(tabelas)
Número
Baixo valor
Incremento fixo
Valor dependente 1
Valor dependente 2
••••
Valor dependente 50
Valores
dependentes (R)
Valor dependente
Elemento
Fixed_TRA50 Propriedades
(transportadores)
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
258
Elemento Fixed_TRA50
(transportadores)
Propriedades
Tamanho Inteiro 1
Posição inicial 2
ID da posição 2
Zona 2
Status inicial 2
Tamanho Inteiro 2
••••
Posição inicial 50
Identificação da posição 50
Zona 50
Status inicial 50
Tamanho Inteiro 50
Dados da
unidade (R)
Posição
inicial
Posição ID
Zona
Status
inicial
Tamanho
do
veículo
Tamanho
Inteiro
259
B • TCAPAZES
Elemento
Fixed_VAR2R Propriedades
(variáveis)
Número
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 Propriedades
(variáveis)
Número
Opção clara
Tipo de categoria
Tipo de dados
Valor 1
Valor 2
••••
Valor 10
261
Elemento Fixed_VAR10
(Variáveis) Propriedades
Valores
iniciais (R)
Valor
Uso
Descrição
Elemento
Fixed_VAR10R Propriedades
(variáveis)
Número
Opção clara
Tipo de categoria
Tipo de dados
Valores
iniciais (R)
Valor 1
Valor 2
Valor
10
Uso
Descrição
260
B • TCAPAZES
Elemento
(variáveis)
Número
Opção clara
Tipo de categoria
Tipo de dados
Valor 1
Valor 2
••••
Valor 50
Valores
iniciais (R)
Valor
Uso
Descrição
262
Elemento
(variáveis)
Número
Opção clara
Tipo de categoria
Tipo de dados
Valor 1
Valor 2
••••
Valor 200
Valores
iniciais (R)
Valor
Uso
Descrição
263
B • TCAPAZES
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 AccmLength

dados
Valores AttrID, real
Nome do tipo de ActivityAreaLevel

dados
Valores Inteiro
Nome do tipo de AllorSpecific

dados
Valores "Todos", "Específico"
Nome do tipo de Tempo de chegada

dados
Valores “Hora”, “Primeiro”, “Último”,
“Aquecimento”, “Todos”, “Tecla”,
“Mensagem”
Nome do tipo de ArrivalType

dados
Valores “Estação”, “Fila”, “Bloquear”, “Evento”
264
Nome do tipo de AttrID

dados
Valores IdOrInt, SymbolName "(" Inteiro ")",
SymbolName "(" Inteiro "," Inteiro ")", "A ("
Inteiro ")"
Nome do tipo de BasicTimeUnit

dados
Valores "Segundos", "Minutos", "Horas", "Dias"
Nome do tipo de Capacidade

dados
Valores "Capacidade", "Programação"
Nome do tipo de ConsOrRange

dados
Valores "Constante", "Alcance"
Nome do tipo de ConvType

dados
Valores "Acumulando", "Não Acumulando"
Nome do tipo de CountInitOpt

dados
Valores "Replicar", Sim ou Não
Nome do tipo de CrossDir

dados
Valores "Positivo", "Negativo", "Qualquer um"
Nome do tipo de CrossDirPosNeg

dados
Valores "Positivo negativo"
265
B • TCAPAZES
Nome do tipo de Encontro

dados
Valores Encontro
Nome do tipo de Data hora

dados
Valores Data hora
Nome do tipo de Dia

dados
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 DistExp

dados
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 Ativado desativado

dados
Valores "Ativado desativado"
Nome do tipo de EndOpt

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

dados
Valores "Preempt", "Ignorar", "Aguardar"
Nome do tipo de Tipo de evento

dados
Valores "Usuário", "VBA", "ActiveX"
Nome do tipo de FailType

dados
Valores "Contagem", "Tempo"
Nome do tipo de Fracasso

dados
Valores "Fracasso"
Nome do tipo de FileAccType

dados
Valores “Sequencial”, “Direto”, “Usuário”
Nome do tipo de Formato de arquivo

dados
Valores AnyCharacters
Nome do tipo de Nome do arquivo

dados
Valores AnyCharacters
Nome do tipo de FileStructure

dados
Valores “Não formatado”, “Formato livre”,
“Arquivo WKS”, FileFormat
267
B • TCAPAZES
Nome do tipo de FlowAllocation

dados
Valores “ValueAdded”, “NonValueAdded”,
“Wait”, “Transfer”, “Other”
Nome do tipo de FlowType

dados
Valores "Adicionar", "Transferir", "Remover"
Nome do tipo de FormatType

dados
Valores "Duração", "Calendário"
Nome do tipo de FreqExp

dados
Valores "Valor", "Estado"
Nome do tipo de GlobalPriority

dados
Valores "QTIME", "LVF", "HVF"
Nome do tipo de IdOrInt

dados
Valores SymbolName, Inteiro
Nome do tipo de IdOrIntOrRange

dados
Valores SymbolName, Inteiro “-” Inteiro,
Inteiro, SymbolName “-” SymbolName
Nome do tipo de IdOrIntOrReal

dados
Valores SymbolName, Inteiro, Real
268
Nome do tipo de IdOrRealorKey

dados
Valores SymbolName, Real, "INFINITE"
Nome do tipo de InitOpt

dados
Valores "Hold", "Rewind", "Close"
Nome do tipo de InitVar

dados
Valores "J", "M", "NS", "IS", "X" "(" Inteiro ")"
Nome do tipo de LinkType

dados
Valores "Unidirecional", "Bidirecional", "Esporão"
Nome do tipo de Localização

dados
Valores “Estação”, “Interseção”, “Link”
Nome do tipo de LSR

dados
Valores “FCFS”, “LCFS”, “Mais próximo”, “Mais
distante”, “LVF”, “HVF”
Nome do tipo de MD1

dados
Valores "1", "2", "3", "4", "5", "6", "7", "8", "9", "10",
"01",
"02", "03", "04", "05", "06", "07", "08", "09"
Nome do tipo de Método

dados
Valores "RKF", "Euler", "Usuário"
269
B • TCAPAZES
Nome do tipo de Mês

dados
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 NonNegativeReal

dados
Valores Real Não Negativo
Nome do tipo de DataNonNegativeRealorSymbol

dados
Valores Real não negativo, SymbolName
Nome do tipo de NonNegativeRealSymbolName

dados
Valores Real não negativo, SymbolName, "NONE"
Nome do tipo de PositiveInteger

dados
Valores Número inteiro positivo (valores opcionais mín. E
máx.)
Nome do tipo de PositiveReal

dados
Valores Real positivo
Nome do tipo de PreemptDest

dados
Valores Etiqueta, "STO" "(" IdOrInt ")"
Nome do tipo de QBlock

dados
Valores Rótulo, "COMPARTILHADO"
271
Nome do tipo de QSR

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

dados
Valores String entre aspas
Nome do tipo de RangeIndex

dados
Valores Inteiro, Inteiro “..” Inteiro
Nome do tipo de RankingCrit

dados
Valores "FIFO", "LIFO", "LVF", "HVF"
Nome do tipo de RealorInfinite

dados
Valores Real, "infinito"
Nome do tipo de RealorSymbolName

dados
Valores Real, SymbolName
Nome do tipo de RegulatorTimeUnit

dados
Valores "Por segundo", "Por hora", "Por minuto", "Por dia"
Nome do tipo de RepLengthTimeUnit

dados
Valores "Horas", "Dias", "Semanas"
270
B • TCAPAZES
Nome do tipo de ResourceAction

dados
Valores "Espera", "Espera até"
Nome do tipo de ResourceorSet

dados
Valores "Recurso", "Definir"
Nome do tipo de RSR

dados
Valores “CYC”, “RAN”, “POR”, “LRC”, “SRC”, “LNB”,
"SNB", "UR" "(" IdOrInt ")", "ER" "(" IdOrInt ")"
Nome do tipo de Tipo de recurso

dados
Valores "Estacionário", "Posicional", "Distância", "Rede"
Nome do tipo de RestrColumn

dados
Valores "Excluir incluir"
Nome do tipo de Regra

dados
Valores “CYC”, “RAN”, “POR”, “LDS”, “SDS”, “LRC”,
"SRC", "LNQ", "SNQ", "LNB", "SNB",
"UR", "ER", "MIN", "MAX"
Nome do tipo de SaveCrit

dados
Valores "Primeiro", "Último", "Produto", "Soma"
Nome do tipo de SeedInitOpt

dados
Valores YesOrNo, "Comum", "Antitético"
272
Nome do tipo de SensorLocationType

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

dados
Valores "Fatal", "Aviso", "Não"
Nome do tipo de SignedInteger

dados
Valores Inteiro assinado (mínimo opcional, máximo de
valores)
Nome do tipo de Ordenar

dados
Valores "Ascendente", "Descendente", "Não classificado"
Nome do tipo de StateSetType

dados
Valores "Inativo", "Ocupado", "Inativo", "Falha", IdOrInt
Nome do tipo de Status

dados
Valores "Ativo inativo"
Nome do tipo de SystemMap

dados
Valores "Distância", "Rede"
Nome do tipo de Tempo

dados
Valores Tempo
Nome do tipo de TSR

dados
Valores "CYC", "RAN", "POR", "LDS", "SDS", "UR",
"ER"
273
B • TCAPAZES
Nome do tipo de UnitTimeUnit

dados
Valores "Segundos por unidade", "Minutos por unidade",
"Horas por unidade", "Dias por unidade"
Nome do tipo de VehicleSize

dados
Valores "Comprimento", "Zona"
Nome do tipo de Ano

dados
Valores Inteiro
Nome do tipo de ZoneControl

dados
Valores "Iniciar", "Final", Inteiro
274
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 Tipos de saída

entrada
Padrão Padrão
Fila Fila
Aproveitar PickQ
Segure o Tipo QPick
A
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.
275
B • TCAPAZES
CVALIDAÇÃO DE LIGAÇÃO
Tipo de saída Tipo de entrada

Padrão Padrão, Fila, Apreender, Reter Tipo A, Reter Tipo 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
CTIPOS DE LIGAÇÃO SIMAN MÓDULOS
Quadra Conexão Tipo

Acesso Segure o Tipo A
distribuir Segure o Tipo A
Capturar Segure o tipo C
Combinar Segure o tipo C
Grupo Segure o tipo C
PickQ PickQ (no rótulo da fila), Padrão (no rótulo)
Preempt Segure o Tipo A
Continuar Segure o tipo C
QPick QPick (no próximo rótulo oculto), PickQ (no rótulo da fila)
Fila Fila (ponto de entrada), Fila (ponto de saída no próximo rótulo
oculto)
Solicitação Segure o Tipo A
Varredura Segure o tipo C
Aproveitar Aproveitar
Selecione Segure o Tipo A, selecione
Esperar Segure o tipo C
276
C Criando Ajuda Online arquivos
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
Quando você gera o arquivo Sample.tpo, o Arena grava um arquivo de interface de

ajuda chamado
Sample.HHque 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
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
278
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,
279
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.
281
Índice
UMA Barra de ferramentas Design da caixa de

diálogo◼110
Teclas do acelerador◼ 109 Painel Janela Design de Diálogo◼ 33
Processo Avançado ◼ 2 185 Grade de propriedades de
Painel de transferência avançada◼ design ◼ 83 objetos de
2 185 Objeto de animação formulário de diálogo ◼ 79
exibir na visualização do operandos ocultos ◼ 79
usuário ◼ 170 na janela Operand Explorer ◼ 78
lógica ◼ 115 objetos operandos ◼ 79
Modelo de arena ◼ repetir objetos de grupo ◼
185 Atribuir módulo 79 Caixa de ferramentas
◼ 45 Criação ◼80
automática ◼ 75, 96 Caixa de

ferramentas
B controla a
CheckBox ◼ 81
Caractere de citação de volta
Caixa combo◼ 81
usar para referenciar operando ◼ DatePicker◼ 81
117 Painel Processo básico ◼ 2 185 DateTimePicker◼ 81
DialogButton◼ 81
C FilePicker◼ 81
Alterações nas GroupBox◼ 81
instâncias◼ 75 Caixas de HiddenOperand◼ 81
seleção Linha◼ 81
opções de personalização◼ 147 RadioButtonGroup◼ 81
acesso especial para referências na RepeatGroupDialog◼ 81
janela lógica◼ 123 RepeatGroupTable◼ 81
Prancheta ◼ 75, 113, 116, 171, 182 Texto◼ 81
Compatibilidade do módulo Caixa de texto◼ 81
existente TimePicker◼ 81
instâncias◼ 75 Botão Exibir caixa de diálogo◼ 78
Módulo de atribuição condicional◼ Formulário de diálogo ◼ 82
159 Informações de Contato ◼ 5 organizando controles◼
Criando arquivos de ajuda 83 disposição ◼ 39.
online◼ 277 Centro de Suporte controles de
ao Cliente ◼ 4 travamento◼ 83
abertura ◼ 82
D redimensionando◼ 83
Conexão direta ◼ 125
Propriedade
na lógica do módulo ◼
DataType
126 Elemento
SIMAN◼ 102
Distâncias◼ 206
padrão ◼ 101
Convenções de
Decidir módulo ◼ 44
documentos◼ 3 Conjunto
Definindo lógica de modelagem◼
de documentação ◼ 3
40. Módulo de atraso ◼ 48.
Desenhar objeto
Grade de propriedades de design ◼ 83
camada oculta / visível◼
170 na visualização do usuário ◼ 170
280
E J
Elemento◼ 183
Propriedade InUserView◼ 103
elementos de dados ◼ 183
definir versus opção de referência ◼
193 definindo através da hierarquia ◼ eu
186, 190 definindo via elemento Carregando um arquivo da biblioteca
operando ◼ 186 listas ◼ 186, 188 do painel de modelos (.tpl)◼ 66.
sublista◼ 189, 192 Janela lógica
tipos especiais conectando interruptores◼ 153
comprimento fixo◼ 204 instâncias do módulo de conexão ◼
escondido◼ 204 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◼
entrada◼ 94 113 módulo oculto (utlarena.tpo) e
Ponto de comuta ◼ 157
entrada várias conexões e comutadores◼ 148
referência de operando na janela abertura ◼ 112
lógica◼127 validação / referência de pontos de saída repetidos e
operando ◼ 95 operandos ◼37. conexão única◼ 149
interruptores regras e diretrizes◼ 161
conectados ◼ 167 comutadores nas instâncias do
objeto de visualização módulo ◼ 124
do usuário ◼ 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 M
operando◼ 95 Repetivel ◼ 136 Janela modelo
interruptores diferenças com a janela lógica◼ 113
conectados ◼ 167 Módulo ◼ 96
objeto de visualização lidar com◼ 163, 165
do usuário ◼ 166 processo de construção da lógica◼ 41.
F
Cam
po
usar no capítulo Janela Lógica ◼ 116 repetidor◼ 139
opção requerida◼ 73
tipos de fluxo de
G entidade◼ 125 Definição do
módulo
Imagens globais ◼ 55 mudanças e instâncias existentes◼
75 copiando ◼ 75
H excluindo◼ 66.
Socorro ◼ 3 referências de operando◼
116 renomeando ◼ 66.
Criação de arquivo de
Janela de definição de módulo
ajuda ◼ 277 Arquivo de
◼ 65 abertura ◼ 67
interface de ajuda ◼ 279
Alça do módulo ◼ 165
Operandos ocultos ◼ 79
282
EuNDEX
◼
Instância do módulo
usar no modelo ou janela lógica ◼
112 Tutorial de criação de módulo ◼ 9
29 4
Atribuir módulo◼ 45
Decidir módulo ◼ 44 p
Módulo de atraso ◼ 48. o
Módulo de processo ◼ 45 n
Módulo de fila ◼ 42. t
Elemento Filas ◼ 50. o
Módulo de liberação ◼
48. Módulo de apreensão d
◼ 42. Elemento Variáveis e
◼ 50.
s
N a
í
Propriedade de nome◼
d
91 repetir grupos ◼
a
103
Elemento NetworkLink◼ 206 ◼
Número de saídas alternativas ◼ 140
9
O 4
Ajuda online ◼ 3
Abrindo uma janela de definição de
módulo◼ 67 Abrindo uma nova biblioteca
de painéis de modelos (.tpl)
Arquivo ◼ 65
Operando
valor padrão ◼ 117, 199
dicas de design ◼ 211
exibir na visualização do
usuário ◼167
operando repetível◼ 169
elemento ◼ 190
propriedade◼ 194
definindo elemento e propriedade
usando operando oculto◼ 199
grupo de
repetição◼ 195
referências a ◼ 114
alternar várias referências com o conjunto
fornecido◼ 120
relatório de operando de arquivo da
biblioteca do painel de modelos
(.tpl)◼ 68
referência de valor na definição do
comutador◼ 177 Operandos
básico◼ 92
elemento◼ 93
ponto de entrada
escondido◼ 103 Q
propriedade◼ 93
funções especiais◼ 98 Módulo de fila◼ 42.
especificando a propriedade DataType◼ 101 especificando a Elemento Filas ◼ 50.
propriedade InUserView ◼ 103 especificando o
LogicProperties R
propriedade◼ 92 Opções de personalização do
especificando a propriedade Name◼ 91 especificando grupo de botões de opção ◼
o SwitchName 147
propriedade◼ 102 acesso especial para referências na
especificando a propriedade Value◼ 97 Operandos, janela lógica◼ 123
usando ◼ 91 Operandos de referência
objetos de animação na visualização do
P usuário◼ 170 combinando repetição e
Ícone do painel◼ 181 dicas de design ◼ não repetição
213 referências◼ 136
tamanho e exibição no painel de modelos◼ 73, 182 concatenando texto e referência◼ 118
contendo várias referências ◼ 119
Janela de ícone do painel◼ 181 tutorial ◼ 56.
Módulo de processo◼ 45 operandos do ponto de entrada ◼ 127
Barra de Projetos ◼ 9 23, 58, 72 73 na definição do comutador ◼ 177
Propriedade◼ 183, 187 várias referências ao mesmo operando◼ 122
ponto de saída repetido ◼ 138
liga propriedades ◼ 203
operandos repetidos◼ 131
283
Módulo de liberação ◼
usar na janela lógica ◼ 152
48. Repetir grupo◼ 103
usar nas janelas de definição de módulo ◼
mudar de uso ◼ 180
176
Repetir objetos de grupo◼
79 Repetir grupos
acessando o número de tuplas e o número T
do tu-◼ 107 Suporte técnico◼ 4 Modelo
combinando valores repetidos de documentação◼ 214
operando em um único valor◼107 Barra de ferramentas de
profundidade de definição e regras de desenvolvimento de modelos◼ 33
referência◼ 105 regras de referência ◼ 129 Painel Modelo ◼ 65
especificando a propriedade alterando o nome de exibição◼
LogicProperties◼ 104 72 criando nova janela ◼ 32.
especificando a propriedade Name◼ destacando ◼ 76
103 Lógica repetível ◼ 139 tamanho e exibição do
Módulo repetível◼ 139 ícone◼ 73 privado ◼ 72
Analisar erros ◼ 68 Alterações no arquivo da
biblioteca do painel de
S modelos (.tpl) e módulo
existente
Modelos de amostra ◼ 3
instâncias◼ 75
Elemento de segmentos
verificação de erros / avisos◼ 67
◼ 206 Módulo de
Arquivo de objeto do painel de
apreensão ◼ 42.
modelo (.tpo)
Elemento Sets ◼ 206
mudanças e instâncias existentes◼ 75
Modelo SIMAN ◼ 185
gerar .tpo na janela do modelo ◼ 67, 71
Lógica de simulação e design de
fornecendo ao modelador ◼ 71
módulos◼ 111 Biblioteca Smarts ◼ 3
Regras relativas à Ligação a
Transferência de Janelas Lógicas◼ 115
estação◼ 125 na Fechamento da
lógica do módulo janela do
◼125
modelo◼ 66.
Estatisticas excluindo um módulo◼ 66.
dicas para projetar no módulo◼ 215 gerando o arquivo de objeto do painel de
Submodelo ◼ 112 modelo (.tpo)◼ 71
Interruptor ◼ 175 renomeando um
e elemento◼ 202 e módulo◼ 66. relatório ◼
propriedade ◼ 203 68
anexado ao objeto de animação opções de modelo◼
da visualização do 71 versão ◼ 71
usuário◼ 171
Caixa de ferramentas,
definindo◼ 176
usando o controle
definição◼ 71, 176, 177
CheckBox ◼ 87
comparação de operando com valor◼
Controle ComboBox◼ 85
178 na instância do módulo da janela
Controle DatePicker ◼ 89
lógica ◼ 124 nome ◼ 177
Controle DateTimePicker ◼ 88
regras sobre definições◼ 179 opção de
Controle DialogButton ◼ 87
arquivo da biblioteca do painel de
Controle FilePicker◼ 90 Controle
modelos (.tpl)
GroupBox ◼ 85 HiddenOperand
relatório◼
control◼ 91 Controle de linha ◼
68 85 Controle RadioButtonGroup
◼ 86 Controle
RepeatGroupDialog ◼87
284
EuNDEX
Controle
Elemento Variáveis◼
RepeatGroupTable◼88
50. Suporte na Web ◼
Controle de texto ◼84 4O que é isso?
Controle TextBox◼ 85 Socorro◼279
os controles ◼ 83
IDs de contexto◼
Controle TimePicker
279 Unidades
◼90
mundiais ◼ 163
Vestígio
Visualização do
dicas de design para uso na
usuário ◼ 163
definição de módulo ◼
dicas de design ◼ 213
215
concepção ◼ 53
Rastrear nas definições do
modificações pelo modelador◼
módulo ◼ 160 Cursos de
164 Janela de visualização do
treinamento ◼ 5
usuário ◼ 163
Tuple
tutorial ◼ 53 Arquivo
valor da troca◼ 179
Utlarena.tpo ◼ 156
módulo de atribuição condicional◼
W 159 módulo oculto ◼ 157
Propriedade Value◼ 97
285
2
Fixed_EXP4R
Element Properties
(Expressions)
Number
1-D Array Index
2-D Array Index
Data Type
Expression Values
(R) Expression 1
Expression 2
Expression 3
Expression 4
Usage
Description
242
ARENA TEMPLATE DEVELOPER’S GUIDE
Fixed_EXP7R
Element Properties
(Expressions)
Number
1-D Array Index
2-D Array Index
Data Type
Expression Values
(R) Expression 1
Expression 2
••••
Expressio
n7
Usage
Description
Fixed_EXP30R
Element Properties
(Expressions)
Number
1-D Array Index
2-D Array Index
Data Type
Expression Values
(R) Expression 1
Expression 2
••••
Expression
30
Usage
Description
243
B • TABLES
Fixed_EXP5
Element Properties
(Expressions)
Number
1-D Array Index
2-D Array Index
Data Type
Expression 1
Expression 2
••••
Expression 5
Expressions
(R)
Expression
Usage
Description
Fixed_EXP10
Element Properties
(Expressions)
Number
1-D Array Index
2-D Array Index
Data Type
Expression 1
Expression 2
••••
Expression 10
Expressions
(R)
Expression
Usage
Description
244
Fixed_EXP10R
Element Properties
(Expressions)
Number
1-D Array Index
2-D Array Index
Data Type
Expression Values
(R) Expression 1
Expression 2
••••
Expression
10
Usage
Description
Fixed_EXP15
Element Properties
(Expressions)
Number
1-D Array Index
2-D Array Index
Data Type
Expression 1
Expression 2
••••
Expression 15
Expressions
(R)
Expression
Usage
Description
245
B • TABLES
Fixed_EXP20
Element Properties
(Expressions)
Number
1-D Array Index
2-D Array Index
Data Type
Expression 1
Expression 2
••••
Expression 20
Expressions
(R)
Expression
Usage
Description
Fixed_EXP25
Element Properties
(Expressions)
Number
1-D Array Index
2-D Array Index
Data Type
Expression 1
Expression 2
••••
Expression 25
Expressions
(R)
Expression
Usage
Description
246
Fixed_EXP50
Element Properties
(Expressions)
Number
1-D Array Index
2-D Array Index
Data Type
Expression 1
Expression 2
••••
Expression 50
Expressions
(R)
Expression
Usage
Description
Fixed_FRE50
Element Properties
(Frequencies)
Number
Type
Name
Output File
Report ID
Value or Range 1
Value 1
High Value 1
Category 1
Category Option 1
Value or Range 2
247
B • TABLES
Fixed_FRE50 Element
(Frequencies) Properties
Value 2
High Value 2
Category 2
Category Option 2
••••
Value or Range 50
Value 50
High Value 50
Category 50
Category Option 50
Categories
(R) Value or
Range Value
High Value
Category
Category
Option
Fixed_LEV10R
Element (Levels) Properties
Number
1-D Array Index
2-D Array Index
Initial Values
(R) Value 1
Value 2
••••
Value
10
248
Fixed_LEV50
Element (Levels) Properties
Number
1-D Array Index
2-D Array Index
Value 1
Value 2
••••
Value 50
Initial Values
(R) Value
Fixed_PAR50
Element Properties
(Parameters)
Number
1-D Array Index
2-D Array Index
Value 1
Value 2
••••
Value 50
Initial Values
(R) Value
249
B • TABLES
Fixed_RAT10R
Element (Rates) Properties
Number
1-D Array Index
2-D Array Index
Initial Values
(R) Value 1
Value 2
••••
Value
10
Fixed_RAT50
Element (Rates) Properties
Number
1-D Array Index
2-D Array Index
Value 1
Value 2
••••
Value 50
Initial Values
(R) Value
251
Fixed_REC20
Element (Recipes) Properties
Static Name 1
Value 1
Static Name 2
Value 2
••••
Static Name 20
Value 20
Statics (R)
Static
Name
Value
Fixed_REC50
Element (Recipes) Properties
Static Name 1
Value 1
Static Name 2
Value 2
••••
Static Name 50
Value 50
Statics (R)
Static
Name
Value
250
B • TABLES
Fixed_RES50
Element Properties
(Resources)
Number
Capacity or Schedule
Integer or Sched ID
Capacity Entity Rule
Stateset ID
Initial State
Failure 1
Failure ID 1
Failure Entity Rule 1
Failure 2
Failure ID 2
••••
Failure 50
Failure ID 50
Failures
(R)
Failure
Failure
ID
Failure Entity Rule
252
Fixed_RLN50
Element Properties
(Reportlines)
Number
Report ID
Format
Expression 1
Expression 2
••••
Expression 50
Expressions
(R)
Expression
Fixed_SCH50
Element (Schedules) Properties
Resource Capacity 1
Capacity Duration 1
Resource Capacity 2
Capacity Duration 2
••••
Resource Capacity 50
Capacity Duration 50
Capacities (R)
Resource
Capacity
Capacity
Duration
253
B • TABLES
Fixed_SEQ3
Element Properties
(Sequences)
Number
Stations (R)
Station ID
Variable 1
Value 1
Variable 2
Value 2
Variable 3
Value 3
Assignments
(R) Variable
Value
Fixed_SEQ20
Element Properties
(Sequences)
Number
Stations (R)
Station ID
Variable 1
Value 1
Variable 2
Value 2
••••
Variable 20
Value 20
Assignments
(R) Variable
Value
254
Fixed_SEQ40
Element Properties
(Sequences)
Number
Stations (R)
Station ID
Variable 1
Value 1
Variable 2
Value 2
••••
Variable 40
Value 40
Assignments
(R) Variable
Value
Fixed_SEQ50
Element Properties
(Sequences)
Number
Stations (R)
Station ID
Variable 1
Value 1
Variable 2
Value 2
••••
Variable 50
Value 50
Assignments
(R) Variable
Value
255
B • TABLES
Fixed_SEQ100
Element (Sequences) Properties
Number
Stations (R)
Station ID
Variable 1
Value 1
Variable 2
Value 2
••••
Variable 100
Value 100
Assignments
(R)
Variable
Value
Fixed_SEQ250
Element (Sequences) Properties
Number
Stations (R)
Station ID
Variable 1
Value 1
Variable 2
Value 2
••••
Variable 250
Value 250
Assignments
(R)
Variable
Value
256
Fixed_SET50
Element (Sets) Properties
Member 1
Member 2
••••
Member 50
Members
(R)
Member
Fixed_STA50
Element (Statesets) Properties
Number
State Name 1
Stateset Type 1
State Name 2
Stateset Type 2
••••
State Name 50
Stateset Type 50
States (R)
State
Name
Stateset
Type
257
B • TABLES
Fixed_TAB50
Element (Tables) Properties
Number
Low Value
Fixed Increment
Dependent Value 1
Dependent Value 2
••••
Dependent Value 50
Dependent Values
(R) Dependent
Value
Fixed_TRA50
Element Properties
(Transporters)
Number
Number of Units
System Map Type
Map ID
Control
Velocity
Acceleration
Deceleration
Turning Velocity
Initial Position 1
Position ID 1
Zone 1
Initial Status 1
Vehicle Size 1
258
Fixed_TRA50 Element
(Transporters) Properties
Size Integer 1
Initial Position 2
Position ID 2
Zone 2
Initial Status 2
Vehicle Size 2
Size Integer 2
••••
Initial Position 50
Position ID 50
Zone 50
Initial Status 50
Vehicle Size 50
Size Integer 50
Unit Data
(R) Initial
Position
Position ID
Zone
Initial
Status
Vehicle
Size Size
Integer
259
B • TABLES
Fixed_VAR2R
Element (Variables) Properties
Number
1-D Array Index
2-D Array Index
Clear Option
Category Type
Response Category Type
Data Type
Initial Values
(R) Value 1
Value 2
Usage
Description
Fixed_VAR10
Number
1-D Array Index
2-D Array Index
Clear Option
Category Type
Data Type
Value 1
Value 2
••••
Value 10
261
Fixed_VAR10 Element
(Variables) Properties
Initial Values
(R) Value
Usage
Description
Fixed_VAR10R
Number
1-D Array Index
2-D Array Index
Clear Option
Category Type
Data Type
Initial Values
(R) Value 1
Value 2
••••
Value
10
Usage
Description
260
B • TABLES
Fixed_VAR50
Number
1-D Array Index
2-D Array Index
Clear Option
Category Type
Data Type
Value 1
Value 2
••••
Value 50
Initial Values
(R) Value
Usage
Description
262
Fixed_VAR200
Number
1-D Array Index
2-D Array Index
Clear Option
Category Type
Data Type
Value 1
Value 2
••••
Value 200
Initial Values
(R) Value
Usage
Description
263
B • TABLES
Data Types
As described in “The Dialog Design Window” chapter, there are SIMAN data types
that are available. In most cases, these data types are derived from the valid field
entries from modules in the Blocks and Elements panels. See Help for more
information on a specific block or element and its valid field values.
Data type definitions

The following is a list of the available SIMAN data types. The Data Type Name
refers to the name of the data type as it appears in the Data Type property drop-
down list entry in the dialog box design window. Values are the permitted values a
modeler can enter. If these values are a literal text string or punctuation, they are
enclosed in double quotes. If the value is another data type (either a standard or
SIMAN data type), then the value has no double quotes. Allowable Control Types
specifies what control types are permitted with the data type.
Data Type Name AccmLength

Values AttrID, real
Data Type Name ActivityAreaLevel

Values Integer
Data Type Name AllorSpecific

Values “All”, “Specific”
Data Type Name ArrivalTime

Values “Time”, “First”, “Last”, “Warmup”,
“Every”, “Keyhit”, “Message”
Data Type Name ArrivalType

Values “Station”, “Queue”, “Block”, “Event”
264
Data Type Name AttrID

Values IdOrInt, SymbolName “(“ Integer “)”,
SymbolName “(“ Integer “,” Integer “)”, “A(“
Integer “)”
Data Type Name BasicTimeUnit

Values “Seconds”, “Minutes”, “Hours”, “Days”
Data Type Name Capacity

Values “Capacity”, “Schedule”
Data Type Name ConsOrRange

Values “Constant”, “Range”
Data Type Name ConvType

Values “Accumulating”, “Nonaccumulating”
Data Type Name CountInitOpt

Values “Replicate”, YesOrNo
Data Type Name CrossDir

Values “Positive”, “Negative”, “Either”
Data Type Name CrossDirPosNeg

Values “Positive”, “Negative”
265
B • TABLES
Data Type Name Date

Values Date
Data Type Name DateTime

Values Date, Time
Data Type Name Day

Values “11”, “12”, “13”, “14”, “15”, “16”, “17”, “18”,
“19”,
”20”, “21”, “22”, “23”, “24”, “25”, “26”, “27”,
“28”,
“29”, “30”, “31”, MD1
Data Type Name DistExp

Values “EXPO(Mean)”, “NORM(Mean,StdDev)”,
“TRIA(Min,Mode,Max)”,
UNIF(Min,Max)”,
“ERLA(ExpoMean,k)”,
“GAMM(Beta,Alpha)”,
“JOHN(G,D,L,X)”,
“LOGN(LogMean,LogStd)”,
“POIS(Mean)”,
“WEIB(Beta,Alpha)”,
“CONT(P1,V1,...)”, “DISC(P1,V1,...)”,
Expression
Data Type Name EnabledDisabled

Values “Enabled”, “Disabled”
Data Type Name EndOpt

Values “Error”, “Dispose”, “Rewind”, “Ignore”
266
Data Type Name EntRule

Values “Preempt”, “Ignore”, “Wait”
Data Type Name EventType

Values “User”, “VBA”, “ActiveX”
Data Type Name FailType

Values “Count”, “Time”
Data Type Name Failure

Values “Failure”
Data Type Name FileAccType
Values “Sequential”, “Direct”, “User”
Data Type Name FileFormat

Values AnyCharacters
Data Type Name FileName

Values AnyCharacters
Data Type Name FileStructure

Values “Unformatted”, “Free Format”, “WKS
File”, FileFormat
267
B • TABLES
Data Type Name FlowAllocation

Values “ValueAdded”, “NonValueAdded”,
“Wait”, “Transfer”, “Other”
Data Type Name FlowType

Values “Add”, “Transfer”, “Remove”
Data Type Name FormatType

Values “Duration”, “Calendar”
Data Type Name FreqExp

Values “Value”, “State”
Data Type Name GlobalPriority

Values “QTIME”, “LVF”, “HVF”
Data Type Name IdOrInt

Values SymbolName, Integer
Data Type Name IdOrIntOrRange

Values SymbolName, Integer “-” Integer,
Integer, SymbolName “-”
SymbolName
Data Type Name IdOrIntOrReal

Values SymbolName, Integer, Real
268
Data Type Name IdOrRealorKey

Values SymbolName, Real, “INFINITE”
Data Type Name InitOpt

Values “Hold”, “Rewind”, “Close”
Data Type Name InitVar

Values “J”, “M”, “NS”, “IS”, “X” “(“ Integer”)”
Data Type Name LinkType

Values “Unidirectional”, “Bidirectional”, “Spur”
Data Type Name Location
Values “Station”, “Intersection”, “Link”
Data Type Name LSR

Values “FCFS”, “LCFS”, “Closest”, “Farthest”,
“LVF”, “HVF”
Data Type Name MD1

Values “1”, “2”, “3”, “4”, “5”, “6”, “7”, “8”, “9”, “10”,
“01”,
“02”, “03”, “04”, “05”, “06”, “07”, “08”, “09”
Data Type Name Method

Values “RKF”, “Euler”, “User”
269
B • TABLES
Data Type Name Month

Values “11”, “12”, “13”, “14”, “15”, “16”, “17”, “18”,
“19”,
“20”, “21”, “22”, “23”, “24”, “25”, “26”, “27”,
“28”,
“29”, “30”, “31”, MD1
Data Type Name NonNegativeReal

Values Non Negative Real
Data Type Name DataNonNegativeRealorSymbol

Values Non Negative Real, SymbolName
Data Type Name NonNegativeRealSymbolName

Values Non Negative Real, SymbolName, “NONE”
Data Type Name PositiveInteger
Values Positive Integer (optional min, max values)
Data Type Name PositiveReal

Values Positive Real
Data Type Name PreemptDest

Values Label, “STO”“(“ IdOrInt “)”
Data Type Name QBlock

Values Label, “SHARED”
271
Data Type Name QSR

Values “CYC”, “RAN”, “POR”, “LRC”, “SRC”, “LNQ” ,
“SNQ”, “UR” “(“ IdOrInt “)”, “ER” “(“ IdOrInt
“)”
Data Type Name QuotedString

Values Quoted String
Data Type Name RangeIndex

Values Integer, Integer “..” Integer
Data Type Name RankingCrit

Values “FIFO”, “LIFO”, “LVF”, “HVF”
Data Type Name RealorInfinite

Values Real, “Infinite”
Data Type Name RealorSymbolName

Values Real, SymbolName
Data Type Name RegulatorTimeUnit

Values “Per Second”, “Per Hour”, “Per Minute”, “Per
Day”
Data Type Name RepLengthTimeUnit

Values “Hours”, “Days”, “Weeks”
270
B • TABLES
Data Type Name ResourceAction

Values “Hold”, “HoldUntil”
Data Type Name ResourceorSet

Values “Resource”, “Set”
Data Type Name RSR

Values “CYC”, “RAN”, “POR”, “LRC”, “SRC”, “LNB”,
“SNB”, “UR” “(“ IdOrInt “)”, “ER” “(“ IdOrInt
“)”
Data Type Name ResourceType

Values “Stationary”, “Positional”, “Distance”, “Network”
Data Type Name RestrColumn

Values “Exclude”, “Include”
Data Type Name Rule

Values “CYC”, “RAN”, “POR”, “LDS”, “SDS”, “LRC”,
“SRC”, “LNQ”, “SNQ”, “LNB”, “SNB”,
“UR”, “ER”, “MIN”, “MAX”
Data Type Name SaveCrit

Values “First”, “Last”, “Product”, “Sum”
Data Type Name SeedInitOpt

Values YesOrNo, “Common”, “Antithetic”
272
Data Type Name SensorLocationType

Values “Specific Level”, “Percentage Capacity”
Data Type Name Severity

Values “Fatal”, “Warning”, “No”
Data Type Name SignedInteger

Values Signed Integer (optional min, max values)
Data Type Name Sort

Values “Ascending”, “Descending”, “Unsorted”
Data Type Name StateSetType
Values “Idle”, “Busy”, “Inactive”, “Failed”, IdOrInt
Data Type Name Status

Values “Active”, “Inactive”
Data Type Name SystemMap

Values “Distance”, “Network”
Data Type Name Time

Values Time
Data Type Name TSR

Values “CYC”, “RAN”, “POR”, “LDS”, “SDS”, “UR”,
“ER”
273
B • TABLES
Data Type Name UnitTimeUnit

Values “Seconds Per Unit”, “Minutes Per Unit”, “Hours
Per Unit”, “Days Per Unit”
Data Type Name VehicleSize

Values “Length”, “Zone”
Data Type Name Year

Values Integer
Data Type Name ZoneControl

Values “Start”, “End”, Integer
274
Connection point data types and SIMAN

blocks
Entry or exit point types
There are six different entry point types and six different exit point types, as noted
below.
Entry Types Exit Types

Standard Standard
Queue Queue
Seize PickQ
Hold Type A QPick
Hold Type B Select
Hold Type C Balk
DESCRIPTIONS
The three different entry types (Hold Type A, B, and C) are used to distinguish those
modules that can connect to a QPick module (Access, Request, and so on) and those
that cannot (Capture, Group). The Hold Type B is used when a Queue block is
required.
A Seize entry type is required for the Select exit type since only a Seize module can
follow a Select module.
275
B • TABLES
CONNECTION VALIDATION
Exit Type Entry Type

Standard Standard, Queue, Seize, Hold Type A, Hold Type C
Queue Seize, Hold Type A, Hold Type B, Hold, Type C
PickQ Queue
QPick Seize, Hold Type A, Hold Type B
Select Seize
CONNECTION TYPES ON SIMAN MODULES
Block Connection Type

Access Hold Type A
Allocate Hold Type A
Capture Hold Type C
Combine Hold Type C
Group Hold Type C
PickQ PickQ (on queue label), Standard (on balk label)
Preempt Hold Type A
Proceed Hold Type C
QPick QPick (on hidden next label), PickQ (on queue label)
Queue Queue (Entry point), Queue (Exit Point on hidden next label)
Request Hold Type A
Scan Hold Type C
Seize Seize
Select Hold Type A, Select
Wait Hold Type C
276
C Creating Online Help Files
Arena provides template developers with a help interface that allows designers to
associate online help files with their templates, providing template users with detailed
instructions on the use of various modules and their options.
Here is an example of how the template help interface works. Let’s assume that you
have created a template called Sample.tpl that contains a module called Server.
Let’s also assume that the Server module’s main dialog box looks like this:
Figure C.1 Main dialog box of the Server module
The repeat group and secondary dialog boxes (Server Names and Options) look
like this:
Figure C.2 Server Names Repeat Group Figure C.3 Options Secondary dialog box
dialog box
277
When you generate the Sample.tpo file, Arena writes out a help interface file called
Sample.HHthat looks something like this:
Automated help: *.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
The left column (for example, #define TemplateContents) displays the Help Context
ID that will be used by the Help Authoring Tool (for example, RoboHelp®). The
right column displays the Help Context Number that will be referenced by Arena.
This file serves as a “map” between your Help Authoring Tool and Arena.
The first entry for every template’s .HH file contains the entry #define
TemplateContents. This context ID allows template developers to have a Table of
Contents topic in the template help file. When a template panel is attached to the
Project Bar, the template name is added to the list of attached templates in Arena’s
Help menu. Clicking any of these menu options will automatically display the help
topic associated with the TemplateContents context ID. See the instructions below to
find out how to associate a context ID with a help topic.
The remaining entries are determined as follows: Each module will have an entry
corresponding to the module name (for example, #define Server). By default, this
context ID is used when you click the Context Sensitive Help toolbar button (on the
Standard toolbar) and then click a module button in the Project Bar. This could be
used to display a general overview of the types of uses for that module. This
behavior can be changed by editing the Module Help Option in the Template
Options dialog box.
In Arena, every module dialog box (including secondary dialog boxes and dialog
boxes displayed when adding or editing items in repeat groups) contains a Help
button. Each Help button can display either the main help topic for that module or a
unique help topic for that particular dialog box of the module. For example, the
Server module displayed above has three dialog boxes: the main dialog box (Server),
and two secondary dialog boxes (Server Names repeat group and Options). Each of
these dialog boxes has a Help button. The Server dialog box’s Help button will
display the main help topic for the module. The Server Names dialog box can display
either the main help topic (as displayed by the Server dialog box) or a unique help
278
C • CREATING ONLINE HELP FILES
topic specific to the Server Names dialog box. The Options dialog box can display
either the main help topic (as displayed by the Server dialog box) or a unique help
topic specific to the Options dialog box.
To enable or disable unique help topics for individual dialog boxes, you specify a
dialog box form object’s UniqueHelpTopic property as True or False in the module
definition’s dialog box design window. By default, this property is set to True for a
dialog box form. If you enable a unique help topic for a particular dialog box but fail
to create a corresponding topic in your help file, users who press the Help button in
that dialog box will receive a message from the Windows® Help system indicating
that the topic does not exist in the help file. Therefore, you should always set the
UniqueHelpTopic to True if you do not intend to create a help topic specific to the
dialog box.
Similarly, in the module definition’s dialog box design window, each dialog box
form object includes a WhatsThisHelp property that is specified as True or False.
This option will provide the dialog box with a question mark in the top right of the
title bar, allowing the user to ask for help on a specific operand in the dialog box. If
you enable this option but fail to provide a topic for each specific operand in your
help file, users who click the question mark and then click an operand will receive a
message that the topic does not exist. Therefore, you should not enable the “What’s
This?” help option if you do not intend to create a help topic for each operand in the
dialog box.
When the help interface (.HH) file is generated along with the .tpo file, the context
IDs are written for each dialog box according to the following rules: the main dialog
box’s context ID is created by appending an underscore (_) to the module name, for
example, Server_. The context IDs for all other dialog boxes are created by
appending the dialog box name to the module name, separated by underscores;
spaces embedded in dialog box and repeat group names are converted to
underscores. For example, the Server Names dialog box would generate a context
ID of Server_Server_Names. The Options dialog box’s context ID would be
Server_Options.
Context IDs for “What’s This?” help are created for each operand by appending the
operand name to the dialog box name with an underscore. For example, the Server
Names dialog box would generate context IDs Server_Server_TimeName and
Server_Quantity for the operands Server Name and Quantity in the Server Names
dialog box.
To use the help interface file generated above, you need to first use your Help
Authoring Tool to create help information in the form of “topics.” Next you tell your
Help Authoring Tool that you have a help interface or “map” file (for example,
279
Sample.HH). To do this in RoboHelp, you need to add the file to the list of “map
files” for the project by following the procedure outlined below:
5. From the Project menu, choose Setup.
6. Click the Advanced tab. Under the Setup Section heading, highlight the (Map)/
Include Files item, then click the Setup Section heading.
7. Choose the help interface file provided by Arena (for example, Sample.HH)
from the list and click Add.
8. Click OK several times until you’ve closed all the dialog boxes and are back to
the help document.
Next you need to associate the individual help topics in your help document with the
context IDs contained in the help interface file. To do this, you must edit each help
topic and locate the Context String field (you might need to click the Advanced
button to open up this section of the dialog box). Click the Choose button to open the
Choose Context String Provided By Development Team dialog box. Make sure that
the help interface file provided by Arena is highlighted in the Project Map File field.
Then select the appropriate context ID from the Symbolic Identifier list (for example,
if you were editing the main help topic for the module, you would choose the Server_
context ID). Click OK until you have closed all dialog boxes and are back to the help
document. The topic is now associated with the context ID.
To associate the TemplateContents context ID with your Table of Contents for the
template, you must do the following:
5. From the Project menu, choose Setup.
6. Click the Contents button.
7. Choose the TemplateContents context ID from the list of Context Strings.
8. Click OK several times until you have closed all the dialog boxes and are back
to the help document.
The next time you “make” the help file, it will incorporate the appropriate Help
Context Numbers (the values in the right column of the .HH file) in the .hlp file. The
help file should have the same name as the template file. For example, Sample.tpo
will look for a file called Sample.hlp.
281
Index
A Dialog Design toolbar◼110

Accelerator keys◼ 109 Advanced Dialog Design window◼ 33
Process panel ◼ 2, 185 Design Properties grid ◼ 83
Advanced Transfer panel◼ 2, 185 dialog form objects ◼ 79
Animation object hidden operands ◼ 79
display in user view ◼ 170 Operand Explorer ◼ 78
in logic window ◼ 115 operand objects ◼ 79 repeat
Arena template ◼ 185 group objects ◼ 79
Assign module ◼ 45 Toolbox ◼80
Auto-Create ◼ 75, 96 Toolbox controls
CheckBox ◼ 81
B ComboBox◼ 81
DatePicker◼ 81
Back quote character
DateTimePicker◼ 81
use for referencing operand ◼ 117 DialogButton◼ 81
Basic Process panel ◼ 2, 185 FilePicker◼ 81
GroupBox◼ 81
C HiddenOperand◼ 81
Changes to instances◼ 75 Line◼ 81
Check boxes RadioButtonGroup◼ 81
customizing options◼ 147 RepeatGroupDialog◼ 81
special access for references in logic RepeatGroupTable◼ 81
window◼ 123 Text◼ 81
Clipboard ◼ 75, 113, 116, 171, 182 TextBox◼ 81
Compatibility of existing module TimePicker◼ 81
instances◼ 75 View Dialog Form button◼ 78
Conditional assignment module◼ 159 Dialog form ◼ 82
Contact information ◼ 5 arranging controls◼ 83
Creating online help files◼ 277 layout ◼ 39
Customer Support Center ◼ 4 locking controls◼ 83
opening ◼ 82
D resizing◼ 83
Direct connection ◼ 125
DataType property
in module logic ◼ 126
SIMAN◼ 102
Distances element◼ 206
standard ◼ 101
Document conventions◼ 3
Decide module ◼ 44
Documentation set ◼ 3
Defining modeling logic◼ 40
Draw object
Delay module ◼ 48
hidden/visible layer◼ 170
Design Properties grid ◼ 83
in user view ◼ 170
280
E J
Element◼ 183
InUserView property◼ 103
data elements ◼ 183
define vs. reference option ◼ 193
defining through hierarchy ◼ 186, 190 L
defining via element operand ◼ 186 Loading a template panel library (.tpl)
lists ◼ 186, 188 file◼ 66
sublists◼ 189, 192 Logic window
special types attaching switches◼ 153
fixed-length◼ 204 connecting module instances ◼ 148
hidden◼ 204 decomposing processes ◼ 111
inverted◼ 206 design hints ◼ 214
switches on elements ◼ 202 detaching switches◼ 153
Elements panel ◼ 185 differences with model window◼ 113
entry◼ 94 hidden module (utlarena.tpo) and
Entry point switches ◼ 157
operand reference in logic window◼127 multiple connections and switches◼ 148
operand validation/reference ◼ 95 opening ◼ 112
operands ◼37 repeating exit points and single
switches attached ◼ 167 connection◼ 149
user view object ◼ 166 rules and guidelines◼ 161 switches
Errors/warnings◼ 67 in module instances ◼ 124
reviewing◼ 68 verifying logic relative to switches◼ 155
Exit point LogicProperties property ◼ 92
operand◼ 37 repeat groups◼ 104
operand validation/reference◼ 95
repeatable ◼ 136 M
switches attached ◼ 167 Model window
user view object ◼ 166 differences with logic window◼ 113
Module ◼ 96
F handle◼ 163, 165
Field process of building logic◼ 41
use in Logic Window chapter ◼ 116 repeater◼ 139
required option◼ 73
types of entity flow◼ 125
G Module definition
Global pictures ◼ 55 changes and existing instances◼ 75
copying ◼ 75
H deleting◼ 66
Help ◼ 3 operand references◼ 116
renaming ◼ 66
Help file creation ◼ 277
Module definition window ◼ 65
Help interface file ◼ 279
opening ◼ 67
Hidden operands ◼ 79
Module handle ◼ 165
282
INDEX
Module instance hidden◼ 103

use in model or logic window ◼ 112 property◼ 93
Module-building tutorial ◼ 29 special functions◼ 98
Assign module◼ 45 specifying the DataType property◼ 101
Decide module ◼ 44 specifying the InUserView property ◼ 103
Delay module ◼ 48 specifying the LogicProperties
Process module ◼ 45 property◼ 92
Queue module ◼ 42
specifying the Name property◼ 91
Queues element ◼ 50
specifying the SwitchName
Release module ◼ 48 property◼ 102
Seize module ◼ 42
specifying the Value property◼ 97
Variables element ◼ 50
Operands, using ◼ 91
N P
Name property◼ 91
Panel icon◼ 181
repeat groups ◼ 103
design hints ◼ 213
NetworkLink element◼ 206
size and display in template panel◼ 73,
Number of Alternate Outputs ◼ 140
182
Panel icon window◼ 181
O tutorial ◼ 56
Online help ◼ 3 Process module◼ 45
Opening a module definition window◼ 67 Project Bar ◼ 9, 23, 58, 72, 73
Opening a new template panel library (.tpl) Property◼ 183, 187
file ◼ 65 switches on properties ◼ 203
Operand
default value ◼ 117, 199 Q
design hints ◼ 211 display
Queue module◼ 42
in user view ◼167
Queues element ◼ 50
repeatable operand◼ 169
element ◼ 190
property◼ 194 R
defining element and property using Radio button group
hidden operand◼ 199 customizing options ◼ 147
repeat group◼ 195 special access for references in logic
references to ◼ 114 window◼ 123
switching multiple with references to pro- Referencing operands
vided set◼ 120 animation objects in user view◼ 170
template panel library (.tpl) file operand combining repeating and non-repeating
report◼ 68 references◼ 136
value reference in switch definition◼ 177 concatenating text and reference◼ 118
Operands containing multiple references ◼ 119
basic◼ 92 entry point operands ◼ 127
element◼ 93 in switch definition ◼ 177
entry point ◼ 94 multiple references to same operand◼ 122
exit point ◼ 94 repeating exit point ◼ 138
repeating operands◼ 131
283
Release module ◼ 48
use in logic window ◼ 152
Repeat group◼ 103
use in module definition windows ◼ 176
switch use ◼ 180
Repeat group objects◼ 79
Repeat groups T
accessing the number of tuples and the tu- Technical support◼ 4
ple number◼ 107 Template
combining repeating operand values into documenting◼ 214
a single value◼107 Template Development toolbar◼ 33
definition depth and reference rules◼ 105 Template panel ◼ 65
reference rules ◼ 129 changing the display name◼ 72
specifying the LogicProperties creating new window ◼ 32
property◼ 104 detaching ◼ 76
specifying the Name property◼ 103 icon size and display◼ 73
Repeatable logic ◼ 139 private ◼ 72
Repeatable module◼ 139 Template panel library (.tpl) file
Review errors ◼ 68 changes and existing module
instances◼ 75
S checking for errors/warnings◼ 67
Template panel object (.tpo) file
Sample models ◼ 3 changes and existing instances◼ 75
Segments element ◼ 206 generate .tpo in template window ◼ 67, 71
Seize module ◼ 42 providing to modeler ◼ 71
Sets element ◼ 206 rules regarding attachment to logic
SIMAN template ◼ 185 windows◼ 115
Simulation logic and module design◼ 111 Template window
Smarts library ◼ 3 closing◼ 66
Station transfer◼ 125 in deleting a module◼ 66
module logic ◼125 generating the template panel object (.tpo)
Statistics file◼ 71
hints for designing in module◼ 215 renaming a module◼ 66
Submodel ◼ 112 report ◼ 68
Switch ◼ 175 template options◼ 71
and element◼ 202 version ◼ 71
and property ◼ 203
Toolbox, using
attached to user view animation
CheckBox control ◼ 87
object◼ 171
ComboBox control◼ 85
defining◼ 176
DatePicker control ◼ 89
definition◼ 71, 176, 177
DateTimePicker control ◼ 88
operand comparison with value◼ 178
DialogButton control ◼ 87
in logic window module instance ◼ 124
FilePicker control◼ 90
name ◼ 177
GroupBox control ◼ 85
rules regarding definitions◼ 179 HiddenOperand control◼ 91 Line
template panel library (.tpl) file switch control ◼ 85 RadioButtonGroup
report◼ 68 control ◼ 86 RepeatGroupDialog
control ◼87
284
INDEX
RepeatGroupTable control◼88
Variables element◼ 50
Text control ◼84
Web support ◼ 4 What’s
TextBox control◼ 85 the
This? help ◼279
controls ◼ 83
Context IDs◼ 279
TimePicker control ◼90
World units ◼ 163
Trace
User view ◼ 163
design hints for use in module
design hints ◼ 213
definition ◼ 215
designing ◼ 53
Trace in module definitions ◼ 160
modifications by modeler◼ 164
Training courses ◼ 5
User view window ◼ 163
Tuple
tutorial ◼ 53
value of switch in◼ 179
Utlarena.tpo file ◼ 156
conditional assignment module◼ 159
W hidden module ◼ 157
Value property◼ 97
285
2

Templete Developer S Guide - En.pt

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Templete Developer S Guide - En.pt

Hochgeladen von

Copyright:

Verfügbare Formate

®

GUIA DO DESENVOLVEDOR DE MODELOS

O seguinte está incluído na Arena 15.1:

Nova animação do placar

·Set Data Module

·Módulo de dados de conjunto avançado

·Módulo de dados do transportador

·Módulo de dados por segmento

·Módulo de dados de programação

Os seguintes modelos de exemplo foram adicionados à biblioteca de arquivos Smarts:

-Chamada lógica de controle Reneging.doe:Modelo de exemplo de Renegação de chamada em

VAtualizações personalizadas do Designer

Suporte para Sketchup 2017

Suporte à ferramenta de exportação

Atualizações do Crystal Report

Controle ActiveX SymbolFactory

Mecanismo de banco de dados Microsoft JET

O Arena não será mais suportado na plataforma Windows XP.

Módulo Ações do Painel Comum

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

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

5 • A janela Design do diálogo 77

Usando teclas aceleradoras..........................................................................................109

7 • A janela de exibição do usuário 163

8 • A janela do switch 175

9 • A janela de ícone do painel 181

Tipos de elementos especiais.......................................................................................203

A • Diretrizes de design do modelo 211

C • Criando arquivos de ajuda online 277

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

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

Sobre este guia

Onde posso pedir ajuda?

Consulte os guias do usuário

Explore nossos exemplos

Use a biblioteca Smarts

de recursos de modelagem a técnicas de animação. A biblioteca está organizada em

Obter suporte por telefone

Obter suporte da Web

Consulte o site da Arena

Obter serviços de consultoria

Modelagem com Arena - uma visão geral

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

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

Figura 2.2 Janela de modelo de amostra

Depois de definir os módulos que estarão contidos na biblioteca do painel de

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

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

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

2 • ARENA TEMPLATE DDESENVOLVIMENTO

Figura 2.7 Ícone do painel Criar módulo

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

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

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

Design e operandos da caixa de diálogo

operandos e sua organização em uma ou mais caixas de diálogo para o módulo. Um

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

seção para adicionar controles da interface do usuário aos formulários da caixa de

é criado através da construção de um "submodelo" da Arena. A janela Logic,

Figura 2.13 Caixa de diálogo para o módulo Auxiliar de hospitalização