Editando e Executando um Script¶

Editar um Script¶

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

Uma caixa de diálogo pop-up aparecerá, para selecionar o tipo de script a ser criado:

Escolha Script vazio para novos scripts, Scripts Pre-Run ou Post-Run para scripts que serão chamados automaticamente a partir de experimentos durante a execução, e Script de Experimento do Modelo de Quatro Etapas para scripts que serão usados em um diagrama de experimento de modelo de quatro etapas.

estrutura predefinida de Scripts Pre-Run e Post-Run¶

Há um requisito obrigatório de que ambos esses scripts contenham a seguinte função para verificar qualquer pré-requisito que o script possa ter. O restante da codificação do script deve estar contido nessa função. A função de filtro retornará True se o experimento puder ser executado ou False se algo estiver ausente ou inválido (a execução será então 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 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, nesse caso, a funcionalidade útil de realce encontrada em editores melhores não esteja disponível.

Para mover código entre o editor python no Aimsun Next (que 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 Import para adicionar um ou mais scripts existentes a serem executados antes do script. Eles serão executados em ordem usando seus identificadores.

Execução de um script¶

Um Python Script pode ser executado a partir de seu editor ou de seu menu de contexto na Pasta Project /Script. Use o Executar botão ou 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 External File e digitando o caminho. Para salvar no arquivo externo as modificações feitas durante a edição do código do script, use o Salvar botão.

No Interface do usuário guia 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 o Adicionar Script a um Menu opção 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, isso significa que não há nenhum objeto específico associado a esta execução do script.

Ao executar um script:

• __name__ está definido como __main__ para o script executado (este é 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¶

Ao executar um script, a ordem de execução é:

1. O script inicial (consulte Initialization abaixo)
2. Qualquer script importado
3. O código do script

Caminhos de Busca para Módulos¶

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

1. Ao executar um script a partir 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 Additional Python Path. Múltiplos caminhos separados por ; são permitidos.
4. Pasta de Plugins do Aimsun Next

Se 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 incorporada do Aimsun Next
2. Use pip para instalar o novo módulo
3. Adicione ao Aimsun Next a pasta site-packages onde o módulo foi instalado, usando a entrada em System Preferences

Inicialização¶

O ambiente de scripting no Aimsun Next é inicializado executando o script initial6.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 edição do modelo, bem como aquelas para usar os recursos oferecidos pelos plug-ins:

• PyANGKernel: classes do Aimsun Kernel.
• PyANGGui: classes Aimsun GUI.
• PyANGDTA: classes Aimsun DTA.
• PyTrafficProfilePlugin, PyGKPedestrians, PyPrintLayout, PyDetectionPattern: outras classes de objetos.
• PyMacroKernelPlugin, PyMacroModelPlugin, PyMacroAdjustmentPlugin, PyMacroPTPlugin, PyMacroToolPlugin, PyFrankWolfePlugin, PyIncrementalPlugin, PyStochasticPlugin, PyMSAPlugin, PyPTAdjustmentPlugin, PyPTFrequencyBasedPlugin, : capacidades Macroscópicas do Aimsun.
• PyKalmanPlugin, PyDynamicDepartureAdjustmentPlugin: Recursos adicionais de Aimsun Adjustment.
• PyFourStepsPlugin, PyLandUsePlugin, PyDistributionPlugin, PyModalSplitPlugin: capacidades de modelo de quatro etapas do Aimsun.
• PyAnalyser: classes auxiliares para comparação,
• PyIsochronesPlugin: Classes auxiliares para isócronas.
• PyGShapeImporter, PyGTFSImporter: recursos de scripting para importação de arquivos SHP e GTFS.

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

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

• modelo: contém o modelo de rede atual.
• target: contém o objeto a partir do qual o script é executado, se o script estiver vinculado a um tipo de objeto.
• seleção: 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, agora você pode definir um dos scripts disponíveis no pasta Scripts como script "Fast Access". Ao selecionar um ou vários objetos, o script "Fast Access" pode ser executado usando o atalho de teclado [Ctrl + J].

Observe que apenas um script pode ser definido como script "Fast Access". Para definir um script como script "Fast Access", clique com o botão direito nele e selecione a opção Definir como Acesso Rápido do Menu de Contexto. Uma vez concluído, seu ícone ficará colorido em azul.

Os scripts de "Acesso Rápido" não funcionam com o target objeto, mas usando apenas um 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 "Fast Access" a partir do Menu de Contexto para essa 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 oferece a opção de executar um script contido em um arquivo externo quando o Aimsun Next é iniciado usando a linha de comando com o –script opção. A sintaxe é:

"Aimsun Next.exe" –script python_script.py

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

Normalmente, a primeira coisa que o script fará é carregar uma rede. As etapas são get o objeto da GUI e executar o loadNetwork método:

gui = GKGUISystem.getGUISystem().getActiveGui()
# Load a network
gui.loadNetwork( "vitex.ang" )

A rede pode conter o caminho completo (ou seja, c:/my nets/vitex.ang). Observe que o separador de pastas usa 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 PyANGKernel import *
from PyANGGui import *

def main(argv):
    if len(argv) < 4:
        print "Usage: "Aimsun Next.exe" -script %s ANG_FILE " % argv[2]
        return -1
    # Get the GUI
    gui = GKGUISystem.getGUISystem().getActiveGui()
    # Load a network
    if gui.loadNetwork(argv[3]):
        model=gui.getActiveModel()
        # Here you can do things with the model
        # Save and close the network
        gui.save()
        gui.closeDocument(model)
        # Quit the GUI
        gui.forceQuit()
    else:
        gui.showMessage( GGui.eCritical, "Open error", "Cannot load the network" )

main(sys.argv)

Então, para chamar o script quando o Aimsun Next for iniciado, use -script opção de linha de comando.

"Aimsun Next.exe" –script python_script.py my_network.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 que contém o script
• argv[3] será a rede.

Depois que a rede é carregada, o modelo pode ser acessado usando o GGui::getActiveModel método 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 Aimsun Next Console, uma versão do Aimsun Next sem a interface gráfica do usuário e, portanto, particularmente adequada para simular rapidamente muitas replicações de um modelo já calibrado. A sintaxe é:

aconsole.exe –script python_script.py

O console não abre uma janela gráfica nem permite qualquer interação do usuário com a aplicação; ele apenas executa o script fornecido e então 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 vista inicial…).

O Aimsun Next Console está disponível em assinaturas anuais das edições Aimsun Next Pro, Advanced ou Expert.

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

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

import sys

from PyANGKernel import *
from PyANGConsole import *

def main( argv ):
    if len( argv ) < 3:
        print str("Usage: aconsole -script %s ANG_FILE MATRIX_ID"%(argv[0]))
        return -1
    # Start a Console
    console = ANGConsole()
    # Load a network
    if console.open( argv[1] ):
        model = console.getModel()  
        print "load network"
        matrix = model.getCatalog().find( int(argv[2]) )
        if matrix != None:
            print "matrix accessed"
        console.close()
    else:
        console.getLog().addError( "Cannot load the network" )
        print "cannot load network"


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 é definida automaticamente pelo sistema, contém os parâmetros usados ao invocar o script a partir da linha de comando. Ao usar aconsole, o primeiro argumento (indexado a partir de zero) é o nome do script e, em seguida, o restante dos argumentos é numerado de 1 a N.

Por exemplo:

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

• argv[0] será python_script.py,
• argv[1] será my_network.ang
• argv[2] will be 100.

O script verifica se todos os argumentos obrigatórios foram fornecidos antes de continuar; caso contrário, encerra exibindo as informações sobre o uso correto

if len( argv ) < 3:
    print "Usage: aimsun -script %s ANG_FILE MATRIX_ID" % argv[0]
    return -1

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

O corpo principal do script é encapsulado em uma função, main, chamada por estas 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á executada automaticamente, enquanto se ele for importado para outro script

import python_script.py

não faz nada a menos que sua função main é chamado.