Edição e Execução de um Script

Edição de um Script

Scripts podem ser escritos dentro do Aimsun Next, utilizando um editor que fornece destaque de sintaxe. Crie um novo script usando o menu Projeto/Novo ou a opção Novo na pasta Projeto / Scripts.

Um diálogo pop-up aparecerá, a fim de selecionar o tipo de script a ser criado:

Escolha Script Vazio para novos scripts, Scripts Pré-Execução ou Pós-Execução para scripts que serão chamados automaticamente de experimentos ao executar, e Script de Experimento do Modelo Quatro Passos para scripts que serão usados em um diagrama de experimento de modelo de quatro passos.

Estrutura pré-definida de Scripts Pré-Execução e Pós-Execução

Há um requisito obrigatório de que ambos os scripts devem conter a seguinte função para verificar qualquer pré-requisito que o script possa ter. O restante da codificação do script deve estar contido nesta função. A função de filtro retornará True se o experimento puder ser executado ou False se algo estiver faltando ou inválido (a execução será cancelada). A assinatura da função é:

def filter( experiment ):

    ...
    return True

Edição Externa

Se preferir, é possível editar scripts com softwares mais familiares ou sofisticados, particularmente se os scripts forem armazenados fora do arquivo ANG principal. Uma lista de editores externos particularmente adequados para Python pode ser encontrada em http://wiki.python.org/moin/PythonEditors. Como os scripts são arquivos de texto, eles podem ser editados com os editores de texto mais básicos, como o Wordpad no Microsoft Windows, embora, neste caso, a funcionalidade de destaque útil encontrada em editores melhores não esteja disponível.

Para mover código entre o editor python no Aimsun Next (que irá salvar scripts dentro do arquivo ANG) e o editor externo escolhido, basta usar as operações normais de selecionar, copiar [Ctrl-C] e colar [Ctrl-V].

Scripts Importados

Use a configuração Importar para adicionar um ou mais scripts existentes a serem executados antes do script. Eles serão executados na ordem usando seus identificadores.

Executando um Script

Um Script Python pode ser executado tanto a partir de seu editor quanto de seu menu de contexto na Pasta Projeto / Script. Use o botão Executar ou o atalho Ctrl+E para executar dentro do editor.

O script também pode ser salvo em um arquivo externo marcando a caixa de seleção Arquivo Externo e digitando o caminho. Para salvar as modificações feitas enquanto edita o código do script no arquivo externo, use o botão Salvar.

Interface do Usuário do editor de scripts, um script também pode ser atribuído a um tipo de objeto. O script então aparecerá no menu de contexto de qualquer objeto desse tipo, sob o item Scripts. O objeto selecionado pode ser acessado dentro do script usando a variável target.

Use a opção Adicionar Script a um Menu para atribuir um script a um tipo de objeto.

Por exemplo, o script para imprimir o ID do objeto selecionado é:

print target.getId()

Antes de usar a variável target, é uma boa prática testar se ela existe:

if target != None:
    print target.getId()

Se a verificação for aprovada, isso significa que o script é iniciado a partir do menu de contexto de um objeto; se target for None, significa que não há nenhum objeto específico associado a essa execução do script.

Ao executar um script:

• __name__ é definido como __main__ para o script executado (esse é o script principal)
• __name__ é definido como o nome do script ao executar um script importado antes do script principal
• __file__ é definido como o caminho do arquivo externo quando o script está em um arquivo

Ordem de Execução

Quando um script é executado, a ordem de execução é:

1. O script inicial (veja Inicialização abaixo)
2. Qualquer script importado
3. O código do script

Caminhos de Pesquisa para Módulos

Por padrão, o Aimsun Next usará os seguintes caminhos para buscar módulos ao fazer uma chamada import:

1. Ao executar um script de um arquivo externo, sua pasta
2. A pasta que contém o arquivo ANG
3. Caminhos definidos nas Preferências do Sistema para Python usando a entrada Caminho Python Adicional. Vários caminhos separados por ; são permitidos.
4. Pasta de Plugins do Aimsun Next

Se você precisar adicionar módulos adicionais, por exemplo, pandas, faça o seguinte:

1. Instale uma versão do Python compatível com a versão integrada do Aimsun Next
2. Use pip para instalar o novo módulo
3. Adicione a pasta site-packages onde o módulo foi instalado ao Aimsun Next usando a entrada nas Preferências do Sistema

Inicialização

O ambiente de script no Aimsun Next é inicializado executando o script initial5.py localizado na pasta Program Files/Aimsun/Aimsun Next X.X/shared/scripts/model ou equivalente.

Este script importa os seguintes módulos Python, que contêm as classes fundamentais do Aimsun necessárias para a edição do modelo:

• PyANGBasic: classes Qt.
• PyANGKernel: classes do Kernel do Aimsun.
• PyANGGui: classes GUI do Aimsun.

Para usar as capacidades oferecidas pelos plug-ins, os módulos relacionados devem ser importados. Por exemplo, para calcular uma matriz de travessia estática dentro de um script, o módulo PyMacroToolPlugin deve ser importado

from PyMacroToolPlugin import *

A Tabela na Seção de Arquitetura lista os módulos a serem importados para ter acesso a uma classe.

O script de inicialização então redireciona a saída padrão para a janela de log do Aimsun e, finalmente, pré-inicializa as seguintes variáveis:

• model: contém o modelo da rede atual.
• target: contém o objeto do qual o script é executado, se o script estiver vinculado a um tipo de objeto.
• selection: contém os objetos atualmente selecionados.

Script de Acesso Rápido

Para permitir a execução mais rápida de um script Python específico, em cada modelo do Aimsun Next, você pode agora definir um dos scripts disponíveis na Pasta Scripts como "script de acesso rápido". Ao selecionar um ou vários objetos, o "script de acesso rápido" pode ser executado usando o atalho de teclado [Ctrl + J].

Observe que apenas um script pode ser definido como "script de acesso rápido". Para definir um script como "script de acesso rápido", clique com o botão direito sobre ele e selecione a opção Definir Como Acesso Rápido no Menu de Contexto. Uma vez feito isso, seu ícone será colorido de azul.

Os scripts de "Acesso Rápido" não funcionam com o objeto target, mas somente usando uma seleção de objetos. Como esses objetos não serão filtrados por tipo, para evitar possíveis problemas com diferentes tipos de objetos, você deve usar a seguinte estrutura de filtro:

for object in selection:
    if object.isA("GKSection"):

Para executar o "script de acesso rápido" a partir do Menu de Contexto para aquela seleção de objetos (clique com o botão direito em qualquer objeto da seleção), selecione o tipo de objeto específico em Configurações > Adicionar Script a um Menu.

Scripts de Inicialização

GUI do Aimsun Next

O Aimsun Next fornece a opção de executar um script contido em um arquivo externo quando o Aimsun Next é iniciado usando a linha de comando com a opção –script. A sintaxe é:

"Aimsun Next.exe" –script python_script.py

O Aimsun Next iniciará como de costume, mas, em vez de esperar que o usuário abra ou crie uma rede, ele executará o script. Nesse momento, portanto, apenas a GUI está disponível.

Geralmente, a primeira coisa que o script fará é carregar uma rede. Os passos são obter o objeto GUI e executar o método loadNetwork:

gui = GKGUISystem.getGUISystem().getActiveGui()
# Carregar uma rede
gui.loadNetwork( "vitex.ang" )

A rede pode conter o caminho completo (ou seja, c:/meus_nets/vitex.ang). Observe que o separador de pasta utiliza a barra (/) e não a barra invertida (\). Se nenhum caminho for especificado, a pasta atual será usada.

Também é possível ler o caminho da rede a ser carregada a partir dos argumentos da linha de comando sys.argv.

import sys

from PyANGBasic import *
from PyANGKernel import *
from PyANGGui import *

def main(argv):
    if len(argv) < 4:
        print "Uso: "Aimsun Next.exe" -script %s ARQUIVO_ANG " % argv[2]
        return -1
    # Obter a GUI
    gui = GKGUISystem.getGUISystem().getActiveGui()
    # Carregar uma rede
    if gui.loadNetwork(argv[3]):
        model=gui.getActiveModel()
        # Aqui você pode fazer coisas com o modelo
        # Salvar e fechar a rede
        gui.save()
        gui.closeDocument(model)
        # Sair da GUI
        gui.forceQuit()
    else:
        gui.showMessage( GGui.eCritical, "Erro de abertura", "Não é possível carregar a rede" )

main(sys.argv)

Então, para chamar o script à medida que o Aimsun Next é iniciado, use a opção de linha de comando -script.

"Aimsun Next.exe" –script python_script.py minha_rede.ang

Observe que argv contém todos os argumentos da linha de comando, ou seja.

• argv[0] será "Aimsun Next.exe",
• argv[1] será -script,
• argv[2] será o arquivo contendo o script
• argv[3] será a rede.

Uma vez que a rede é carregada, o modelo pode ser acessado usando o método GGui::getActiveModel da seguinte forma:

model =gui.getActiveModel()

Console do Aimsun Next

É possível executar um script contido em um arquivo externo para controlar a aplicação Console do Aimsun Next, uma versão do Aimsun Next sem interface gráfica do usuário e, portanto, particularmente adequada para simular rapidamente muitas réplicas de um modelo já calibrado. A sintaxe é:

aconsole.exe –script python_script.py

A console não abre uma janela gráfica nem fornece qualquer interação do usuário com a aplicação, ele apenas executa o script fornecido e depois encerra. A principal vantagem é a velocidade, pois qualquer código gráfico no Aimsun Next não é executado (animação durante a simulação, criação da janela principal, criação de uma visualização inicial…).

O Console do Aimsun Next está disponível nas assinaturas anuais das edições Pro, Avançada ou Expert do Aimsun Next.

Para permitir interação, a console adiciona uma nova classe chamada ANGConsole. Esta classe oferece métodos para carregar uma rede e obter o GKModel criado, para salvar a rede e para fechá-la.

O seguinte exemplo carrega uma rede, acessa uma matriz nela e, em seguida, fecha a rede.

import sys

from PyANGBasic import *
from PyANGKernel import *
from PyANGConsole import *

def main( argv ):
    if len( argv ) < 3:
        print str("Uso: aconsole -script %s ARQUIVO_ANG ID_MATRIZ"%(argv[0]))
        return -1
    # Iniciar um Console
    console = ANGConsole()
    # Carregar uma rede
    if console.open( argv[1] ):
        model = console.getModel()  
        print "rede carregada"
        matrix = model.getCatalog().find( int(argv[2]) )
        if matrix != None:
            print "matriz acessada"
        console.close()
    else:
        console.getLog().addError( "Não é possível carregar a rede" )
        print "não é possível carregar a rede"


if __name__ == "__main__":
    sys.exit(main(sys.argv))

Este exemplo usa a variável argv para acessar o nome da rede a ser carregada. Essa variável, que é automaticamente definida pelo sistema, contém os parâmetros usados ao invocar o script a partir da linha de comando. Ao usar a aconsole, o primeiro argumento (indexado a partir de zero) é o nome do script e então o restante dos argumentos é numerado de 1 a N.

Por exemplo:

aconsole.exe –script python_script.py minha_rede.ang 100

• argv[0] será python_script.py,
• argv[1] será minha_rede.ang
• argv[2] será 100.

O script verifica se todos os argumentos necessários foram fornecidos antes de continuar; caso contrário, ele sai dando a informação sobre o uso correto

if len( argv ) < 3:
    print "Uso: aimsun -script %s ARQUIVO_ANG ID_MATRIZ" % argv[0]
    return -1

Se tudo estiver certo, o script usa a Console para carregar a rede. Assim que a rede for carregada, o modelo é adquirido usando o método ANGConsole::getModel().

O corpo principal do script é encerrado em uma função, main, chamada por essas linhas de código

if __name__ == "__main__":
    sys.exit(main(sys.argv))

Isso significa que se o script for executado, sua função main será automaticamente executada, enquanto se for importado para outro script

import python_script.py

não fará nada a menos que sua função main seja chamada.