Skip to content

Funções de Custo

O editor de funções define vários tipos de funções usando duas linguagens diferentes: Python versão 3 e Lua (algumas funções de custo estão excluídas). As funções de custo são apresentadas abaixo:

Modelo de Pasta de Função

O modelo Aimsun Next oferece exemplos das funções de custo codificadas tanto em Python 3 quanto em Lua.


modelo de função

Nota que quando uma função de custo é codificada na linguagem Lua, Lua não permite que um nome de variável seja igual ao nome de qualquer função dentro da função de custo.

Diálogo de Função

Dê um duplo clique em uma função para abrir sua caixa de diálogo. No diálogo da Função você pode:

  • Renomear uma função
  • Selecionar em qual linguagem codificar uma função. Pode ser Python versão 3 ou Lua. Há uma terceira opção chamada "C." Se a opção C for selecionada, entre em contato com support@aimsun.com, pois a função precisa ser codificada internamente.
  • Mudar seu Tipo de Função de uma lista suspensa de funções disponíveis (por exemplo, Custo, Custo Usando Tipo de Veículo, Escolha de Rota e muitas outras)
  • Aperfeiçoar o código da função digitando diretamente na caixa de Código da Função
  • Para verificar a validade do código, clique em Verificar. Você será notificado se o código está correto ou apresentado com detalhes de quaisquer erros.

  • Desenhar um gráfico da função.


    Editor de Função

Desenhar um Gráfico

Como você pode ver na captura de tela anterior, na metade inferior do diálogo da Função, você pode desenhar um gráfico da função conforme ela se aplica a um objeto na rede.

Para desenhar um gráfico da função:

  1. Selecione a partir das listas suspensas a seguir.

    • Experimento (um experimento disponível)

    • Tipo de Veículo

    • Propósito da Viagem (se disponível, 'Nenhum' se não estiver).

  2. Na visualização 2D ativa, clique em um objeto que corresponda ao tipo de função (por exemplo, clique em uma seção para um VDF).

  3. Clique em Desenhar para exibir o gráfico.

Aba de Uso

A aba de Uso lista todos os objetos na rede que utilizam a função.


Editor de Função

  • Clique em um objeto listado para destacá-lo na visualização 2D.

  • Dê um duplo clique em um objeto para abrir seu diálogo e inspecionar ou mudar seus parâmetros.

Unidades

A unidade de tempo padrão para as funções de atraso e custo macroscópicas nos modelos padrão é minutos. A unidade padrão para as funções de custo em simulações dinâmicas é segundos.

Classes de Objetos

Esta seção faz extensas referências a tipos de objetos, ou seja, um GKFunctionCostContext ou um objeto DTATurning. Esses tipos de objetos contêm métodos para obter e definir os atributos do objeto referenciado na chamada da função, por exemplo:

turn.getAttractiveness(vtype)

retorna o valor de atratividade modelado para essa curva, para um tipo de veículo especificado.

Uma visão geral completa das classes pode ser encontrada na Documentação de Scripting do Aimsun Next e o detalhe dos métodos e da hierarquia de classes está na Biblioteca de Scripts que se refere à referência baseada na web gerada automaticamente para os métodos de script. Esta documentação baseada na web deve ser frequentemente consultada ao escrever funções de script para determinar quais dados estão disponíveis para cada classe de objeto.

Variáveis de Cenário e Experimento

Ao escrever funções, variáveis podem ser usadas para definir valores dos parâmetros da função. O valor padrão para uma variável pode ser definido no Editor de Cenário ou variado para um experimento no editor de Experimento. Por exemplo, se houver uma variável usada para controlar o valor retornado por uma função de custo, ela é acessada como mostrado aqui:

def pbf(context, line, stop):
    res = context.experiment.getValueForVariable( "$COST").toFloat()
    res += line.getBoardingFare()
    return res

onde $COST é o nome da variável.

Dados utilizados nas funções que são baseados em viagens ou centróides podem ser armazenados no documento Aimsun como vetores ou como matrizes para dar acesso a eles na função.

Funções de Custo Básicas/Funções de custo usando Tipos de Veículos

Funções de Custo Básicas permitem que o usuário defina, para cada trecho, uma função de custo generalizada que não está restrita apenas ao tempo de viagem. Essas funções são usadas para definir as funções de custo inicial e dinâmica que serão usadas na Atribuição Dinâmica de Rotas. Elas retornam o custo de um trecho sem distinguir por tipo de veículo. Portanto, não podem fazer uso de variáveis que tenham qualquer referência ao tipo de veículo, o que significa que todos os tipos de veículos terão um custo comum.

As Funções de Custo usando tipo de veículo são as mesmas que as funções de custo básicas com a única diferença de que agora o tipo de veículo pode ser usado para distinguir entre custos para veículos.

Assinatura:

cost( context, manager, section, turn, travelTime) -> double

onde:

  • contexto é um objeto Python GKFunctionCostContext.
  • gerenciador é um objeto Python DTAManager.
  • seção é um objeto Python DTASection.
  • curva é um objeto Python DTATurning.
  • travelTime não é usado.

O objeto contexto contém a classe do usuário para a qual a Função de Atraso de Volume está sendo avaliada. No caso de uma função de custo básica, esse objeto não estará disponível. No caso de uma função de custo usando o tipo de veículo, a classe do usuário fornecerá o tipo de veículo para o qual a função está sendo avaliada.

O objeto gerenciador contém a atratividade máxima da curva, peso de atratividade e peso de custo definido pelo usuário.

O objeto seção contém, entre outros, a velocidade da seção, comprimento e capacidade.

O objeto curva contém a origem e o destino da curva, sua atratividade, comprimento e velocidade.

Exemplo Básico

def cost(context, manager, section, turn, travelTime):
    time = section.getStaTravelT(manager)
    dist = section.length3D()
    w = manager.getAttractivenessWeight()
    aTurn = turn.getAttractiveness()
    aMax = manager.getMaxTurnAttractiveness()
    attract = w * (1 - aTurn/aMax)
    cost = 0.9*time + 0.1*dist + attract
    return cost

Exemplo Complexo

No exemplo mais complexo, a velocidade da seção e a velocidade da curva são o mínimo entre a velocidade da seção ou da curva multiplicada pela aceitação do limite de velocidade do veículo e a velocidade máxima desejada do tipo de veículo. O resultado do custo (res) leva em conta os tempos de viagem sem interferências ponderados por um fator de atratividade e é então modificado para adicionar um termo para o custo definido pelo usuário, mais um custo de pedágio com base no comprimento da seção e no valor do tempo do veículo.

def cost(context, manager, section, turning, travelTime):
    sectionSpeed = min(
        section.getSpeed()*manager.getNetwork().getVehicleById(context.getVehicle().getId()).getSpeedAcceptanceMean(),
        manager.getNetwork().getVehicleById(context.getVehicle().getId()).getMaxSpeedMean())
    turnSpeed = min(
        turning.getSpeed()*manager.getNetwork().getVehicleById(context.getVehicle().getId()).getSpeedAcceptanceMean(),
        manager.getNetwork().getVehicleById(context.getVehicle().getId()).getMaxSpeedMean())
    attractivityFactor = 1+
        manager.getAttractivenessWeight()*
        (1-turning.getAttractiveness()/manager.getMaxTurnAttractiveness())
    res = (section.length3D()/sectionSpeed+ turning.length3D()/turnSpeed)*attractivityFactor
    res = res + manager.getUserDefinedCostWeight()*section.getUserDefinedCost()
    tollPrice = 10      #unidades em custo monetário por metro, levando em conta também as unidades de tempo de VoT
    vehicle = context.getVehicle()
    res = res + (section.length3D()+turning.length3D())*tollPrice/vehicle.getValueOfTimeMean()
    return res

Funções de Custo K-Iniciais/Funções de Custo K-Iniciais usando Tipos de Veículos

As funções de Custo K-Iniciais permitem que o usuário defina, para cada trecho, uma função de custo generalizada que não está restrita apenas ao tempo de viagem. Essas funções serão utilizadas na Atribuição Dinâmica de Rotas para calcular os Caminhos Mais Curtos K-Iniciais. Elas retornam o custo de um trecho sem distinguir por tipo de veículo. Portanto, não podem fazer uso de variáveis que tenham qualquer referência ao tipo de veículo, assim todos os tipos de veículos terão um custo comum.

As Funções de Custo K-Iniciais Usando Tipo de Veículo são as mesmas que as Funções de Custo K-Iniciais com a única diferença que agora o tipo de veículo pode ser usado para distinguir entre custos para veículos.

Assinatura:

kinicost( context, manager, section, turn, funcVolume ) -> double

onde:

  • contexto é um objeto Python GKFunctionCostContext.
  • gerenciador é um objeto Python DTAManager.
  • seção é um objeto Python DTASection.
  • curva é um objeto Python DTATurning.
  • funcVolume é o volume para avaliar esta função.

O objeto contexto contém a classe do usuário para a qual a Função de Atraso de Volume está sendo avaliada. No caso de uma função de custo básica, esse objeto não estará disponível. No caso de uma função de custo usando o tipo de veículo, a classe do usuário fornecerá o veículo para o qual a função está sendo avaliada.

O objeto gerenciador contém a atratividade máxima da curva, peso de atratividade e peso de custo definido pelo usuário.

O objeto seção contém, entre outros, a velocidade da seção, comprimento e capacidade.

O objeto curva contém a origem e o destino da curva, sua atratividade, comprimento e velocidade.

O objeto funcVolume é o volume para avaliar esta função.

Exemplo

def kinicost(context, manager, section, turn, funcVolume):
    dist = section.length3D()
    cost = 10*funcVolume + dist
    return cost

Funções de Escolha de Rota

Funções de Escolha de Rota são definidas para serem usadas como um Modelo de Escolha de Rota definido pelo usuário. Elas fornecem a probabilidade para um caminho mais curto.

Assinatura:

rcf( context, manager, origin, destination, pathsRC, pathsOD, pathsAPA, indexPath ) -> double

onde:

  • contexto é um objeto Python GKFunctionCostContext.
  • gerenciador é um objeto Python DTAManager.
  • origem é um objeto Python DTACentroid.
  • destino é um objeto Python DTACentroid.
  • pathsRC é uma lista de objetos Python DTAPossiblePath.
  • pathsOD é uma lista de objetos Python DTAPossiblePath.
  • pathsAPA é uma lista de objetos Python DTAPossiblePath.
  • indexPath é um inteiro.

O objeto contexto contém a classe do usuário para a qual a Função de Escolha de Rota está sendo avaliada e o tempo de simulação.

O objeto gerenciador contém a atratividade máxima da curva, peso de atratividade e peso de custo definido pelo usuário.

O objeto origem contém variáveis para as seções de entrada e porcentagens. Ele representa o centróide de origem.

O objeto destino contém variáveis para as seções de saída e porcentagens. Ele representa o centróide de destino.

O pathRC é uma lista com todos os caminhos calculados usando a escolha de rota para o dado centróide de origem e centróide de destino. Contém objetos DTAPossiblePath.

O pathOD é uma lista com todos os caminhos provenientes das rotas OD. Contém objetos DTAPossiblePath. O campo de custo no DTAPossiblePath representa a porcentagem OD definida na respectiva matriz OD.

O pathAPA é uma lista com todos os caminhos provenientes do arquivo de resultados de Atribuição de Caminhos. Contém objetos DTAPossiblePath. O campo de custo no DTAPossiblePath representa a porcentagem definida no arquivo de resultados de Atribuição de Caminhos.

O indexPath representa o caminho que está sendo calculado. A faixa de indexPath é de 0 ao somatório do comprimento de pathRC, pathOD e pathAPA.

Exemplo

def rcf( context, manager, origin, destination, pathsRC, pathsOD, pathsAPA, indexPath ):
    prob = 0
    if indexPath==0:
        prob 1
    return prob

Ele sempre seleciona o primeiro caminho calculado pela escolha de rota.

Outro exemplo que calcula as probabilidades com base em uma função de seleção logit:

import math
def rcf( context, manager, origin, destination, pathsRC, pathsOD, pathsAPA, indexPath ):
    scaleFactor = 1;
    allPaths = pathsRC
    numPaths = len(allPaths)
    prob=0
    if indexPath<numPaths:
        aux = 0
        pIP = allPaths[indexPath]
        # pIP é um DTAPossiblePath
        costIP = -pIP.getSPCurrentCost(manager, context.userClass.getDTAVehicleType())/3600.0
        for j in range(numPaths):
            if j!=indexPath:
                pJ = allPaths[j]
                costJ = -pJ.getSPCurrentCost(manager, context.userClass.getDTAVehicleType())/3600.0
                aux = aux + math.exp((costIP-costJ)*scaleFactor)
        prob = 1.0/(1.0+aux)
    print('Prob %d %f'%(indexPath, prob))
    return prob

Funções de Atraso de Volume Macro Estáticas

O VDF Macro (Função de Atraso de Volume) é utilizado para modelar o tempo de viagem ou o custo em um trecho ou conexão como uma função de diferentes parâmetros, como o volume do trecho, sua capacidade, seu comprimento, etc. Este tipo de função é levado em conta ao realizar uma atribuição de tráfego estática. Para mais informações sobre VDFs e seu papel na atribuição, consulte as informações sobre Atribuição de Tráfego Estática.

Modelagem de Seção

Assinatura:

vdf( context, section, volume ) -> double

onde:

  • contexto, seção, e volume são objetos Python dos seguintes tipos: GKFunctionCostContext, CMacroSection, e GKFunctionVolume.

O objeto contexto contém a classe do usuário para a qual a Função de Atraso de Volume está sendo avaliada.

O objeto seção contém os parâmetros da seção que podem ser usados na atribuição estática. Os parâmetros que podem ser consultados são: capacidade, comprimento, velocidade, custos definidos pelo usuário, custos adicionais, número de faixas e atributos definidos pelo usuário.

O objeto volume contém o volume para o qual a Função de Atraso de Volume deve ser avaliada. Três volumes diferentes podem ser consultados, volume total, volume por tipo de veículo e volume por classe de usuário. Os Volumes são valores variáveis que mudam durante o processo de atribuição.

Corpo da Função:

No corpo do VDF, qualquer outra função arbitrária que tenha sido definida antes da declaração da função do VDF pode ser usada.

Exemplo

def distance(context, section, volume):
    return section.length3D() / 1000.0

def tTime(context, section, volume):
    t0 = 60.0 * distance(context,section,volume) / section.getSpeed()
    c = section.getCapacity()
    v = volume.getVolume()
    t = t0 * ( 1 + 0.15 * (v/c)**4 )
    return t

def vToll(context, section, volume):
    t = 0.15 * distance(context,section,volume)
    return t

def fToll(context, section, volume):
    t = section.getUserDefinedCost()
    return t

def vdf(context, section, volume):
    c1 = 1.0
    c2 = 0.1
    purpose = context.getPurpose()
    if purpose != None:
        if purpose.getName() == "work":
            c2 = 0.15
    c3 = 0.2
    time = tTime(context,section,volume)
    dist = distance(context,section,volume)
    toll = vToll(context,section,volume)
    toll = toll + fToll(context,section,volume)
    cost = c1 * time + c2 * dist + c3 * toll
    return cost

Modelagem de Conexão

Assinatura:

vdf( context, connection, volume ) -> double

onde:

  • contexto, conexão, e volume são objetos Python dos seguintes tipos: GKFunctionCostContext, CMacroConnection, e GKFunctionVolume.

Os objetos contexto e volume são os mesmos que para a Função de Atraso de Volume usada para seções. O objeto conexão contém os parâmetros da conexão que podem ser usados durante uma atribuição estática. Os parâmetros que podem ser consultados são: comprimento e atributos definidos pelo usuário.

Exemplo

def vdf(context, connection, volume):
    length = connection.getLength()
    c1 = 0.05
    return c1 * length

Funções de Penalidade de Curva Macro Estáticas

O TPF Macro (Função de Penalidade de Curva) é usado para modelar o tempo de viagem ou o custo de uma curva como uma função de diferentes parâmetros, como o volume da curva, seu comprimento, etc. Essa função é levada em conta ao realizar uma atribuição de tráfego estática. Para mais informações sobre TPFs e seu papel na atribuição, consulte as informações sobre Atribuição de Tráfego Estática.

Assinatura:

tpf( context, turn, volume ) -> double

onde:

  • contexto, curva, e volume são objetos Python dos seguintes tipos: GKFunctionCostContext, CMacroTurning, e GKFunctionVolume.

Os objetos contexto e volume são os mesmos que para a Função de Atraso de Volume Estática.

O objeto curva contém os parâmetros da curva que podem ser usados durante uma atribuição estática. Os parâmetros que podem ser consultados incluem a velocidade da curva, os custos definidos pelo usuário, os tempos de semáforo e as capacidades da seção de origem, seção de destino e a curva.

Quando a TPF é definida como "Padrão", isso retorna o custo de fluxo livre para essa distância e velocidade (a função também está disponível no modelo).

Exemplo

def distance(context, turn, volume):
    return turn.length3D() / 1000.0

def tTime(context, turn, volume):
    t = 60.0 * distance(context,turn,volume) / turn.getSpeed()
    return t

def tpf(context, turn, volume):
    c1 = 1.0
    c2 = 0.1
    purpose = context.getPurpose()
    if purpose != None:
        if purpose.getName() == "work":
            c2 = 0.15
    time = tTime(context,turn,volume)
    dist = distance(context,turn,volume)

    cost = c1 * time + c2 * dist
    return cost

Funções de Atraso em Interseções Macro Estáticas

A JDF (Função de Atraso em Interseções) é usada para modelar o tempo de viagem ou o custo em uma curva como uma função de volumes de curvas conflitantes. Essa função é usada na atribuição de tráfego estática. Para mais informações sobre JDFs e seu papel na atribuição, consulte as informações sobre Atribuição de Tráfego Estática.

Quando a JDF é definida como "Nenhum", isso retorna um custo zero.

Assinatura:

jdf( context, turn, singleVolume, ownVolume, conflictVolume ) -> double

onde:

  • contexto, curva, singleVolume, ownVolume, e conflictVolume são objetos Python dos seguintes tipos: GKFunctionCostContext, CMacroTurning, e GKFunctionVolume.

contexto e curva são idênticos ao contexto e curva da TPF.

singleVolume é o volume que passa pela curva.

ownVolume é o volume total de todas as curvas que compartilham uma faixa de origem com a curva.

conflictVolume é o volume total de curvas que geometricamente conflitam com a curva (opção automática) ou o volume de curvas especificado pelo usuário na tabela de Curvas de Conflito no editor de Nó.

Exemplo

def jdf(context, turn, singleVolume, ownVolume, conflictVolume):
    volume = singleVolume.getVolume()
    conflict = conflictVolume.getVolume()
    ratio = 0.0
    if ( volume != 0.0):
        ratio = conflict / volume
    delay = 0.2 * ratio
    return delay

Erros e Restrições de Função de Custo

As funções TPF, JDF e VDF estão sujeitas a certas restrições que irão acionar erros e a cancelamento de simulações dinâmicas, atribuições estáticas e ajustes estáticos.

Essas restrições são as seguintes.

  • o custo de uma curva (soma de TPF + JDF) deve ser > = 0
  • o custo de uma seção (VDF) deve ser > 0
  • uma conexão de centróide unidirecional (VDF) deve ser > = 0
  • uma conexão de centróide bidirecional (VDF) deve ser > 0
  • o custo de trajetória de um supernodo (soma de TPF + JDF) deve ser > 0

Se os custos não atenderem a essas restrições, os processos afetados serão cancelados e mensagens de erro exibidas na janela de Log.

Componentes da Função

Os Componentes da Função são usados para obter saídas extras de Atribuições Estáticas ou Simulações de Tráfego Dinâmico para Seções, Conexões e Curvas, e também para estatísticas de Caminhos.

Se a definição de um VDF, TPF, JDF, DCF, ICF contiver uma subfunção como parte de seu cálculo, então essa subfunção pode ser declarada como um Componente da Função e sua saída exibida nas estatísticas do objeto ao qual a função é atribuída. Além disso, as estatísticas de caminho para cada componente também serão calculadas.

Por exemplo, se um JDF for definido como:

    def jdf(context, turning, singleVolume, ownVolume, conflictVolume):
    jdattribute = calculateJDFAttr( context, turning, singleVolume, ownVolume, conflictVolume)
    delay = computation
    return delay

    def calculateJDFAttr(context, turning, singleVolume, ownVolume, conflictVolume):
    attr = computation
    return attr

onde a função calculateJDFAttr() calcula uma parte do atraso na interseção, então essa subfunção pode ser declarada como um Componente da Função, identificando-a pelo nome 'calculateJDFAttr'.

Exemplo para um DCF:

    def distanceInKm(context, manager, section, turn, travelTime):
        return section.length3D()/1000.0+turn.length3D()/1000.0

    def cost(context, manager, section, turn, travelTime):
        turncost = turn.getStaTravelT(manager)+manager.getUserDefinedCostWeight()*section.getUserDefinedCost()
        return turncost

Note que a função principal não chama necessariamente a subfunção.

No editor de Componentes da Função, a String da Função deve corresponder exatamente ao nome da subfunção correspondente e o Nome será usado como o nome da nova coluna que será gerada.


Componente da Função TPF

O código correspondente à subfunção será avaliado separadamente e uma nova coluna para o objeto será criada contendo os valores que ele computa. Como o Componente da Função é chamado separadamente, a subfunção deve ter exatamente os mesmos argumentos que a função principal para ser corretamente avaliada.

O Componente da Função pode ser visualizado nas séries temporais de um objeto de simulação, como mostrado abaixo, ou seus valores agregados para caminhos e matrizes OD (ponderados pelo número de veículos em cada caminho) na pasta Atribuição de Caminhos.


Componente da Função

Componentes de Função Derivados também podem ser declarados e são computados como a combinação de outros componentes. Por exemplo, se um componente de tempo de viagem e um componente de distância existirem, a velocidade pode ser computada sem declarar uma função de velocidade no VDF, TPF ou JDF, mas como uma combinação dos componentes existentes, como mostrado na imagem abaixo. Em termos de dados agregados para o caminho, usar um Componente de Função Derivada implica uma diferença importante de computação: definir a velocidade como um componente derivado dará a velocidade média do caminho (distância do caminho dividida pelo tempo de viagem do caminho, uma vez que esses dois valores tenham sido calculados), enquanto definir a velocidade através de subfunções como um componente não derivado totalizaria as velocidades através do caminho para computar o valor do caminho para essa coluna.

Em caso de um valor inválido como input em uma Função Derivada para um intervalo, a Série Temporal mostra NaN. Idem para uma divisão por zero. Se todos os intervalos forem inválidos, a função derivada não é incluída.


Componente Derivado da Função

Funções de Escolha Discreta Estocástica

A função de Escolha Discreta Estocástica é usada para calcular as probabilidades de cada caminho sendo utilizado. Essa função é levada em conta na realização de uma Atribuição de Tráfego Estocástica. Para mais informações sobre SDCs e seu papel na atribuição, consulte as informações sobre Atribuição de Tráfego Estática.

Assinatura:

sdc( context, pathChoice ) -> double

onde:

  • contexto e pathChoice são objetos Python dos seguintes tipos: GKFunctionCostContext e GKPathChoice.

contexto é idêntico ao contexto do VDF. pathChoice é um conjunto de caminhos e seus custos.

Exemplo

def sdc(context, pathChoice):
    mu = 100
    total = 0.0
    cost = 0.0
    res = []
    for pathCost in pathChoice.getCosts():
        total += math.exp( mu * 1.0/pathCost )
    for pathCost in pathChoice.getCosts():
        res.append( math.exp(mu * 1.0/pathCost) / total )
    return res

Funções de Peso de Ajuste

A função de Peso de Ajuste é usada para dar diferentes pesos (não fixos) às contagens (à diferença entre as contagens e os volumes atribuídos) no processo de ajuste. Ela retorna um valor que multiplica as Confiabilidades previamente definidas pelo usuário (1 por padrão). Essa função é levada em conta ao fazer um Ajuste OD. Essa função é aplicada a valores dos dados do detector para seções, detectores e curvas, mas não para os valores de comparação adicionais de Saídas/Entradas para os quais as Confiabilidades podem ser definidas na aba Centróides e Seções.

Assinatura:

adw( context, observed ) -> double

onde:

  • observado é um double.

observado é o valor na Série Temporal usado no Ajuste, a contagem que deve ser comparada com o volume atribuído.

Exemplo

def adw( context, observed):
    res = 1.0
    if observed > 0.0:
        res = 1.0/math.pow(observed,0.5)
    else:
        res = 0.0
    return res

Funções de Tempo de Espera do Transporte Público

A função de Tempo de Espera do Transporte Público é usada para modelar o tempo de espera em uma Parada de Transporte Público até embarcar em um veículo. Essa função é usada ao realizar uma Atribuição de Transporte Público. A função padrão de tempo de espera está descrita na seção de Atribuição de Transporte Público.

Assinatura:

pwf( context, interval ) -> double

onde:

  • contexto é um objeto Python do tipo GKFunctionCostContext e intervalo é um double.

contexto fornece o contexto do experimento e intervalo é o intervalo médio combinado entre as chegadas de veículos de transporte nos possíveis corredores de embarque.

Exemplo

def pwf( context, interval ):
    frequency = 60.0 / interval
    res = 20.0 * math.exp(-0.3 * frequency)
    return res

Funções de Embarque do Transporte Público

A função de Embarque do Transporte Público é usada para modelar o custo de embarque em um veículo de transporte em uma Parada de Transporte Público, ou seja, a tarifa de acesso. Essa função é usada ao realizar uma Atribuição de Transporte Público.

Assinatura:

pbf( context, line, stop ) -> double

onde:

  • contexto, linha, e parada são objetos Python dos seguintes tipos: GKFunctionCostContext, PTLine, e PTStop.

contexto fornece o contexto do experimento. linha é a Linha de Transporte que o passageiro deseja embarcar. parada é a parada onde o passageiro está esperando para embarcar.

Exemplo

def pbf(context, line, stop):
    res = line.getBoardingFare()
    return res

Funções de Tarifa por Distância do Transporte Público

A função de Tarifa por Distância do Transporte Público é usada para modelar a tarifa por distância/no veículo em uma viagem de Transporte em uma Linha de Transporte Público. Essa função é usada ao realizar uma Atribuição de Transporte Público.

Assinatura:

pff( context, line, transitsegment ) -> double

onde:

  • contexto, linha, e transitsegment são objetos Python dos seguintes tipos: GKFunctionCostContext, PTLine, e PTSection.

contexto fornece o contexto do experimento. linha é a Linha de Transporte que o passageiro deseja embarcar. transitsegment é o conjunto de segmentos/seções de uma Parada de Transporte a outra que está sendo avaliada.

Exemplo

def pff( context, line, transitsegment ):
    distance = transitsegment.getDistance()/1000.0
    fare = line.getDistanceFare()
    res = distance * fare
    return res

Funções de Atraso do Transporte Público

A função de Atraso do Transporte Público é usada para modelar o tempo de viagem ou o custo em um segmento de Transporte em uma Linha de Transporte Público usando o tempo no veículo. Essa função é usada ao realizar uma Atribuição de Transporte Público.

Assinatura:

pdf( context, line, transitsegment ) -> double

onde:

  • contexto, linha, e transitsegment são objetos Python dos seguintes tipos: GKFunctionCostContext, PTLine, e PTSection.

contexto fornece o contexto do experimento. linha é a Linha de Transporte. transitsegment é o conjunto de segmentos/seções de uma Parada de Transporte a outra que está sendo avaliada.

Exemplo

A função de atraso padrão, aplicada onde não há função definida pelo usuário, é:

def pdf( context, line, transitsegment ):
    distance = transitsegment.getDistance() / 1000.0
    # Velocidade constante 20 km/h
    speed = 20.0 / 60.0
    delay = distance / speed
    # Retornar valor em minutos
    return delay

Funções de Penalidade de Transferência do Transporte Público

A função de Penalidade de Transferência do Transporte Público é usada para modelar a penalidade por transferências de linha para linha durante uma viagem de transporte. Essa função é usada ao realizar uma Atribuição de Transporte Público e é selecionada no editor de Experimento. Geralmente, as pessoas evitam transferências no transporte público devido ao incômodo que elas produzem, portanto, essa função irá penalizar a decisão de fazer uma transferência.

Assinatura:

ptp( context ) -> double

onde:

  • contexto é um objeto Python do tipo GKFunctionCostContext e fornece o contexto do experimento.

Exemplo

def ptp( context ):
    res = 7.0
    # minutos
    return res

Funções de Caminhada Apenas do Transporte Público

A função de Caminhada Apenas do Transporte Público é usada para modelar o custo de uma conexão de origem a destino durante uma viagem de atribuição de transporte público, assumindo que é feita a pé. Essa função é usada ao realizar uma Atribuição de Transporte Público e é selecionada no editor de Experimento. Existem situações em que o custo de usar o Transporte Público é muito alto para os viajantes. Essa função pode ser usada para determinar o custo máximo que os viajantes aceitarão para usar o Transporte Público, acima do qual eles irão descartar essa opção e farão a viagem apenas caminhando.

Assinatura:

wof( context, fromConnector, toConnector ) -> double

onde:

  • contexto é um objeto Python do tipo GKFunctionCostContext e dá o contexto do experimento.
  • fromConnector é um objeto Python do tipo PTCentroidConnector que dá a conexão de Centróide de origem usada na viagem.
  • toConnector é um objeto Python do tipo PTCentroidConnector que dá a conexão de Centróide de destino usada na viagem.

Exemplo Básico

def wof( context, fromConnector, toConnector ):

    walkingSpeed = 6.0 * 1000 / 60 # 6 km/h -> m/min minutos

    res = 0.0
    res += fromConnector.getMaster().length3D()/walkingSpeed
    res += toConnector.getMaster().length3D()/walkingSpeed

    return res

Exemplo Complexo

No exemplo mais complexo, a geometria das conexões não captura o verdadeiro custo das viagens a pé apenas. Por exemplo, se duas áreas estão escassamente conectadas devido a um obstáculo (rodovia, rio, ... modelado como uma GKPolyLine), é improvável que o caminho a pé seja apenas uma linha reta, mas sim um desvio para encontrar uma ponte (GKSection) para atravessar. Nesses casos, se os segmentos de viagem de origem - parada ou parada - destino intersectam algum obstáculo, devemos contabilizar o desvio adicional para cruzar a ponte:

def requiresBridge( centroid, stop ):

res = 0.0

for obstacle in model.getCatalog().findByName("Obstacles").getObjects():

    segment = GKPoints()
    segment.append(centroid.getMaster().getPosition())
    segment.append(stop.getMaster().absolutePosition())

    if obstacle.getPoints().intersects2D(segment):

        return True;

return False

def bridgePenalty( centroid, stop ):

walkingSpeed = 6.0 * 1000 / 60 # 6 km/h -> m/min minutos

bridgesGroup = model.getCatalog().findByName("Bridges")

res = 0.0

if requiresBridge(centroid,stop):

    minimumPenalty = float('inf')

    # Encontrar a ponte mais próxima para cruzar
    candidate = 0.0
    for bridge in bridgesGroup.getObjects():

        bridgeMiddlePoint = bridge.calculateBezierPoint(0.5)

        candidate += bridgeMiddlePoint.distance3D(centroid.getMaster().getPosition())/walkingSpeed
        candidate += bridgeMiddlePoint.distance3D(stop.getMaster().absolutePosition())/walkingSpeed

    if candidate < res:
        res = candidate

return res

def wof( context, fromConnector, toConnector ):

walkingSpeed = 6.0 * 1000 / 60 # 6 km/h -> m/min minutos

res = 0.0
res += fromConnector.getMaster().length3D()/walkingSpeed
res += toConnector.getMaster().length3D()/walkingSpeed

# Custo adicional devido ao desvio da ponte

commonStops = list(set(fromConnector.getStops()).intersection(toConnector.getStops()))

minimumPenalty = float('inf')
for stop in commonStops:

    candidatePenalty = 0.0
    candidatePenalty += bridgePenalty(fromConnector.getCentroid(),stop)
    candidatePenalty += bridgePenalty(toConnector.getCentroid(),stop)

    if candidatePenalty < minimumPenalty:
        minimumPenalty = candidatePenalty

res += minimumPenalty

return res

Funções de Inconforto por Superlotação

A função de Inconforto por Superlotação é uma função não decrescente utilizada para modelar o desconforto gerado por compartilhar um espaço limitado enquanto usa o transporte público com outros passageiros. Essa função é usada ao realizar uma Atribuição de Transporte Público e é selecionada no editor de Linha de Transporte Público. Ela avalia o desconforto com base em quão congestionada está a linha naquele segmento e quanto tempo os passageiros permanecem naquele segmento.

Assinatura:

pcd( context, line, volume, delay ) -> double

onde:

  • contexto é um objeto Python do tipo GKFunctionCostContext que fornece o contexto do experimento.
  • linha é um objeto Python do tipo PTLine que fornece a Linha de Transporte.
  • volume é um double que fornece o volume que viaja de uma Parada de Transporte a outra usando a Linha de Transporte linha.
  • delay é um double que fornece o tempo de atraso de uma Parada de Transporte a outra usando a Linha de Transporte linha.

Exemplo

def pcd( context, line, volume, delay ):
    initialDiscomfort = 1
    seatingCapacity = line.getSeatingCapacity()
    alfa = 6
    beta = 1
    loadFactor = volume/seatingCapacity

    if volume > 0:
        discomfort = initialDiscomfort + (1 - (seatingCapacity/volume)) *initialDiscomfort*beta*math.exp( alfa * (loadFactor-1) )
    else:
        discomfort = initialDiscomfort

    if discomfort < p:
        discomfort = initialDiscomfort

    return discomfort

Funções de Tempo de Permanência do Transporte Público

A função de Tempo de Permanência do Transporte Público é usada para modelar o tempo de permanência dos veículos de transporte nas paradas, levando em conta o volume de passageiros que embarcam e desembarcam durante a atribuição. Use esta função ao realizar uma atribuição estática Atribuição de Transporte Público.

Assinatura:

pdt( context, line, transitstop, alightingVolume, boardingVolume ) -> double

onde:

  • contexto é um objeto Python do tipo GKFunctionCostContext que fornece o contexto do experimento.
  • linha é um objeto Python do tipo PTLine que fornece a Linha de Transporte.
  • ptstop é um objeto Python do tipo PTStop que fornece a Parada de Transporte.
  • alightingVolume fornece o volume agregado de passageiros desembarcando na parada de transporte da linha de transporte durante todo o período de atribuição.
  • boardingVolume fornece o volume agregado de passageiros embarcando na parada de transporte da linha de transporte durante todo o período de atribuição.

Exemplo

Nota: Os coeficientes devem ser modificados de acordo

def pdt( context, line, transitstop, alightingVolume, boardingVolume ):

    defaultDuration = 0.5

    dwellAlighting = 0.01

    dwellBoarding = 0.05

    dwell = defaultDuration + dwellAlighting*(alightingVolume/line.getNbRuns()) + dwellBoarding*(boardingVolume/line.getNbRuns())

    return dwell

Funções de Impedância de Distribuição

A função de Impedância de Distribuição calcula a impedância combinada dos modos disponíveis. Essa função é executada dentro do processo de Distribuição e é selecionada na Área de Distribuição e Divisão Modal.

Assinatura:

dif( context, origin, destination, modes, data ) -> double

onde:

  • contexto (GKFunctionCostContext) fornece o contexto do experimento.
  • origem (GKCentroid) é o centróide de origem.
  • destino (GKCentroid) é o centróide de destino.
  • modos (vetor de GKTransportationMode) são os modos que estão disponíveis e combináveis para o cálculo da impedância combinada.
  • data (SkimDataProvider) dá acesso aos valores de skim e estacionamento.

Exemplo

\# Função de Impedância de Distribuição
from PyLandUsePlugin import *

def dif( context, origin, destination, modes, data ):
    cost = 0.0
    for mode in modes:
        cost += data.getSkimValue( SkimType.eCost, mode, origin, destination )
    return cost / len( modes )

Funções de Dissuassão de Distribuição

A função de Dissuassão de Distribuição calcula a interatividade do centróide como uma função da impedância. Essa função é executada dentro do processo de Distribuição do Modelo de Gravidade e pode ser definida no Experimento de Distribuição do Modelo de Gravidade.

Assinatura:

ddf( context, cost ) -> double

onde:

  • contexto (GKFunctionCostContext) fornece o contexto do experimento.
  • custo (double) é o custo ou impedância.

Exemplo

\# Função de Dissuassão de Distribuição

def ddf( context, cost ):
    return 1.0 / cost

Funções de Utilidade de Distribuição

A função de Utilidade de Distribuição calcula a utilidade de todas as opções de viagem de um origem ou para um destino. Essa função é executada dentro do processo de Distribuição da Escolha de Destino e pode ser definida no Experimento de Distribuição de Destino.

Assinatura:

duf( context, data, modes, centroid, centroids ) -> double

onde:

  • contexto (GKFunctionCostContext) fornece o contexto do experimento.
  • data (SkimDataProvider) dá acesso às matrizes de skim.
  • modos (vetor de GKTransportationMode) são os modos disponíveis e combináveis para o cálculo da utilidade.
  • centroid (GKCentroid) é o centróide de origem ou destino em consideração.
  • centroids (vetor de GKCentroid) são os centróides disponíveis a partir do centróide em consideração.

Exemplo

\# Função de Utilidade de Distribuição
from PyLandUsePlugin import *

def duf( context,data,modes,centroid, centroids):
    uts = []
    c1 = -1.0
    for i in range(len(centroids)):
        res = 0.0
        for mode in modes:
            res += c1 * data.getSkimValue( SkimType.eCost, mode, centroid, centroids[i] )
        uts.append(res)
    return uts

A função de Utilidade de Divisão Modal calcula o valor de utilidade por modo de transporte para cada par OD. Essa função é executada dentro do processo de Divisão Modal e é selecionada na Área de Distribuição e Divisão Modal.

Assinatura:

def msu( context, origin, destination, mode, data ): -> double

onde:

contexto: Uma instância de um GKFunctionCostContext, que dá o contexto do experimento. origem