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 são excluídas). As funções de custo são apresentadas abaixo:
- Funções de Custo
- Modelo de pasta de funções
- Caixa de diálogo de função
- Unidades
- Classes de Objetos
- Variáveis de Cenário e Experimento
- Funções de Custo Dinâmico
- Funções de Custo K-Iniciais
- Funções de Escolha de Rota
- Funções Estáticas Macro de Atraso por Volume
- Funções Estáticas Macro de Penalidade de Movimento de Conversão
- Funções Estáticas Macro de Atraso em Junção
- Erros e Restrições da Função de Custo
- Componentes da Função
- Funções de Escolha Discreta Estocástica
- Funções de Peso de Ajuste
- Funções de Tempo de Espera no Transporte Público
- Funções de Embarque em Transporte Público
- Funções de Tarifa por Distância no Transporte Público
- Funções de Atraso do Transporte Coletivo
- Funções de Penalidade de Transferência de Transporte Público
- Funções de Caminhada Exclusiva do Transporte Público
- Funções de Desconforto por Lotação
- Funções de Tempo de Parada do Transporte Coletivo
- Funções de Impedância de Distribuição
- Funções de Impedância de Distribuição
- Funções de Utilidade de Distribuição
- Funções de Utilidade de Divisão Modal
- Funções de Escolha Discreta de Divisão Modal
- Funções do Modelo de Disponibilidade de Automóvel
- Funções de Park and Ride
- Funções de Penalidade de Chegada para Reprogramação Dinâmica do Horário de Partida OD
Modelo de pasta de funções¶
O template do Aimsun Next oferece exemplos das funções de custo codificadas tanto em Python 3 quanto em Lua.

Caixa de diálogo de função¶
Clique duas vezes em uma função para abrir sua caixa de diálogo. Na caixa de diálogo Função, você pode:
- Renomear a função ou definir seu External ID.
- Selecione 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.
- Altere seu Tipo de função a partir de uma lista suspensa de funções disponíveis (por exemplo, Dynamic Cost,Route Choice, Volume Delay e muitas outras).
- Refine o código da função digitando diretamente no Código da função caixa.
- Para verificar a validade do código, clique em Verificar. Você será notificado de que o código está correto ou receberá detalhes de quaisquer erros.
-
Desenhe um gráfico da função (disponível dependendo do tipo de função).

No corpo de uma função, qualquer outra função arbitrária que tenha sido definida fora da declaração da função pode ser usada.
Nota que quando uma função de custo é codificada na linguagem Lua, Lua não permite que o nome de uma variável seja igual ao nome de qualquer função dentro da função de custo. Assim, por exemplo, se você nomear uma função travelTime(), não poderá usar uma variável com o nome travelTime.
Desenhar um Gráfico¶
Como você pode ver na captura de tela anterior, na metade inferior do diálogo Function, dependendo do tipo de 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 de função:
-
Selecione nas listas suspensas dos seguintes parâmetros.
-
Experimento (um experimento disponível)
-
Tipo de Veículo
-
Finalidade da Viagem (se disponível, 'None' caso contrário)
-
-
Na vista 2D ativa, clique em um objeto que corresponda ao tipo de função (por exemplo, clique em uma seção para uma VDF).
-
Clique Desenhar para exibir o gráfico.
Aba Uso¶
A aba Usage lista todos os objetos na rede que usam a função.

-
Clique em um objeto listado para centralizá-lo e destacá-lo na visualização 2D.
-
Clique duas vezes em um objeto para abrir sua caixa de diálogo e inspecionar ou alterar seus parâmetros.
Unidades¶
A unidade de tempo padrão para as funções macroscópicas de atraso e custo nos templates padrão é minutos. A unidade padrão para as funções de custo em simulações dinâmicas é segundos.
Classes de Objetos¶
Os tipos de objeto 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 esse movimento de conversão, para um tipo de veículo especificado.
Uma visão geral completa das classes pode ser encontrada no Documentação de Scripting do Aimsun Next e o detalhe dos métodos e da hierarquia de classes está no 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 consultada frequentemente ao escrever funções de script para determinar quais dados estão disponíveis para cada classe de objeto.
Alguns tipos de objeto estarão diretamente acessíveis, pois são argumentos das funções, por exemplo, GKFunctionCostContext ou DTATurning classes de objetos.
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 de uma variável pode ser definido no Editor de cenários 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.
Os dados usados nas funções baseadas em viagens ou centroides podem ser armazenados no documento Aimsun como vetores ou como matrizes para dar acesso a eles na função.
Funções de Custo Dinâmico¶
As funções de Custo Dinâmico permitem que o usuário defina, para cada link, uma função de custo generalizado não restrita apenas ao tempo de viagem. Essas funções são usadas para definir as funções de custo dinâmico que serão utilizadas na Atribuição Dinâmica de Rotas. Elas retornam o custo de um link e podem distinguir por tipo de veículo.
Assinatura:
cost( context, manager, section, turn, travelTime) -> double
em que:
- contexto é um GKFunctionCostContext objeto Python.
- gerenciador é um DTAManager objeto Python.
- seção é um DTASection objeto Python.
- movimento de conversão é um DTATurning objeto Python.
- travelTime não é usado.
O contexto objeto fornece acesso, por meio dos métodos correspondentes, entre outros, ao tipo de veículo, motivo da viagem, classe de usuário ou experimento para o qual a Dynamic Cost Function está sendo avaliada.
O gerenciador objeto dá acesso à atratividade máxima do movimento de conversão, ao peso da atratividade e ao peso do custo definido pelo usuário.
O seção objeto dá acesso, entre outros, à velocidade, ao comprimento e à capacidade da seção.
O movimento de conversão object dá acesso à origem e ao destino do movimento de conversão, à sua atratividade, comprimento e velocidade.
Exemplo Básico¶
def cost(context, manager, section, turn, travelTime):
time = section.getStaTravelT(manager, context.getUserClass())
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¶
Em um exemplo mais complexo, sectionSpeed e turnSpeed são o mínimo entre a velocidade da seção ou do movimento de conversão multiplicada pela aceitação do limite de velocidade do veículo e a velocidade desejada máxima do tipo de veículo. O resultado do custo (res) leva em conta os tempos de viagem em fluxo livre ponderados por um fator de atratividade e, em seguida, é modificado adicionalmente para adicionar um termo para o custo definido pelo usuário mais um custo de pedágio baseado 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 #units in monetary cost per meter taking also into account time units of VoT
vehicle = context.getVehicle()
res = res + (section.length3D()+turning.length3D())*tollPrice/vehicle.getValueOfTimeMean()
return res
Funções de Custo K-Iniciais¶
As funções K-Initials Cost permitem ao usuário definir, para cada link, uma função de custo generalizado. Essas funções serão usadas na Dynamic Route Assignment para calcular os K-Initial Shortest Paths.
Assinatura:
kinicost( context, manager, section, turn, funcVolume ) -> double
em que:
- contexto é um GKFunctionCostContext objeto Python.
- gerenciador é um DTAManager objeto Python.
- seção é um DTASection objeto Python.
- movimento de conversão é um DTATurning objeto Python.
- funcVolume é o volume com o qual avaliar esta função.
O contexto objeto dá acesso, por meio dos métodos correspondentes, entre outros, ao tipo de veículo, propósito da viagem, classe de usuário ou experimento para o qual a K-Initial Cost Function está sendo avaliada.
O gerenciador objeto dá acesso à atratividade máxima do movimento de conversão, ao peso da atratividade e ao peso do custo definido pelo usuário.
O seção objeto dá acesso, entre outros, à velocidade, ao comprimento e à capacidade da seção.
O movimento de conversão object dá acesso à origem e ao destino do movimento de conversão, à sua atratividade, comprimento e velocidade.
O funcVolume objeto é o volume com o qual 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¶
As funções Route Choice são definidas para serem usadas como um Route Choice Model definido pelo usuário. Elas fornecem a probabilidade para um caminho mais curto.
Assinatura:
rcf( context, manager, origin, destination, pathsRC, pathsOD, pathsAPA, indexPath ) -> double
em que:
- contexto é um GKFunctionCostContext objeto Python.
- gerenciador é um DTAManager objeto Python.
- origem é um DTACentroid objeto Python.
- destino é um DTACentroid objeto Python.
- pathsRC é uma lista de DTAPossiblePath Objetos Python.
- pathsOD é uma lista de DTAPossiblePath Objetos Python.
- pathsAPA é uma lista de DTAPossiblePath Objetos Python.
- indexPath é um número inteiro.
O contexto objeto fornece acesso, por meio dos métodos correspondentes, entre outros, ao tipo de veículo, motivo da viagem, classe de usuário ou experimento para o qual a Route Choice Function está sendo avaliada.-A def. de contexto é sempre a mesma?
O gerenciador objeto dá acesso à atratividade máxima do movimento de conversão, ao peso da atratividade e ao peso do custo definido pelo usuário.
O origem objeto contém variáveis para as seções de entrada e percentuais. Ele representa o centroide de origem.
O destino objeto contém variáveis para as seções de saída e percentuais. Ele representa o centroide de destino.
O pathRC é uma lista com todos os caminhos calculados usando a escolha de rota para o centroide de destino e o centroide de origem fornecidos. Ela contém objetos DTAPossiblePath.
O pathOD é uma lista com todos os caminhos provenientes das rotas OD. Ela contém objetos DTAPossiblePath. O campo de custo em DTAPossiblePath representa a porcentagem OD definida na respectiva matriz OD.
O pathAPA é uma lista com todos os caminhos provenientes do arquivo de resultados de Path Assignment. Ela contém objetos DTAPossiblePath. O campo de custo no DTAPossiblePath representa a porcentagem definida no arquivo de resultados de Path Assignment.
O indexPath representa o caminho que está sendo calculado. O intervalo de indexPath é de 0 até a soma do comprimento das listas pathRC, pathOD e pathAPA.
Exemplo¶
def rcf( context, manager, origin, destination, pathsRC, pathsOD, pathsAPA, indexPath ):
prob = 0
if indexPath==0:
prob 1
return prob
O exemplo acima sempre seleciona o primeiro caminho calculado de 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 is a 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 Estáticas Macro de Atraso por Volume¶
A Macro VDF (Volume Delay Function) é usada para modelar o tempo de viagem ou o custo em uma seção ou conexão como uma função de diferentes parâmetros, como o volume da seção, sua capacidade, seu comprimento etc. Esse tipo de função é levado em conta ao realizar uma atribuição estática de tráfego. Para obter mais informações sobre VDFs e seu papel na atribuição, consulte a Alocação Estática de Tráfego informações.
Modelagem de seção¶
Assinatura:
vdf( context, section, volume ) -> double
em que:
- contexto, seção, e volume são objetos Python do seguinte tipo: GKFunctionCostContext, CMacroSection, e GKFunctionVolume.
O contexto objeto fornece acesso, por meio dos métodos correspondentes, entre outros, ao tipo de veículo, motivo da viagem, classe de usuário ou experimento para o qual a Volume Delay Function está sendo avaliada.
O seção objeto dá acesso aos parâmetros da seção que podem ser usados na alocaçã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 volume objeto contém o volume para o qual a Volume Delay Function 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 alocação.
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ões¶
Assinatura:
vdf( context, connection, volume ) -> double
em que:
- contexto, conexão, e volume são objetos Python do seguinte tipo: GKFunctionCostContext, CMacroConnection, e GKFunctionVolume.
O contexto e volume os objetos são os mesmos da Função de Atraso por Volume usada para seções. O conexão objeto 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 Estáticas Macro de Penalidade de Movimento de Conversão¶
A Macro TPF (Turn Penalty Function) é usada para modelar o tempo de viagem ou o custo de um movimento de conversão como uma função de diferentes parâmetros, como o volume do movimento de conversão, seu comprimento etc. Esta função é considerada ao realizar uma alocação estática de tráfego. Para obter mais informações sobre TPFs e seu papel na alocação, consulte o Alocação Estática de Tráfego informações.
Assinatura:
tpf( context, turn, volume ) -> double
em que:
- contexto, movimento de conversão, e volume são objetos Python do seguinte tipo: GKFunctionCostContext, CMacroTurning, e GKFunctionVolume.
O contexto e volume objetos são os mesmos que para o Função Estática de Atraso por Volume.
O movimento de conversão o objeto contém os parâmetros do movimento de conversão que podem ser usados durante uma alocação estática. Os parâmetros que podem ser consultados incluem a velocidade do movimento de conversão, os custos definidos pelo usuário, os tempos semafóricos e as capacidades da seção de origem, da seção de destino e do movimento de conversão.
Quando o TPF está definido como "Default" no editor de movimento de conversão, isto retorna o custo em fluxo livre para esta distância e velocidade (a função também está disponível no template).
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 Estáticas Macro de Atraso em Junção¶
A JDF (Junction Delay Function) é usada para modelar o tempo de viagem ou o custo em um movimento de conversão em função dos volumes de movimentos de conversão conflitantes. Esta função é usada na alocação estática de tráfego. Para obter mais informações sobre JDFs e seu papel na alocação, consulte o Alocação Estática de Tráfego informações.
Quando o JDF é definido como "None" no editor de movimento de conversão, isto retorna um custo zero.
Assinatura:
jdf( context, turn, singleVolume, ownVolume, conflictVolume ) -> double
em que:
- contexto, movimento de conversão, singleVolume, ownVolume, e conflictVolume são objetos Python do seguinte tipo: GKFunctionCostContext, CMacroTurning, e GKFunctionVolume.
contexto e movimento de conversão são idênticos ao contexto e ao movimento de conversão do TPF.
singleVolume é o volume que passa pelo movimento de conversão.
ownVolume é o volume total de todos os movimentos de conversão que compartilham uma faixa de origem com o movimento de conversão.
conflictVolume é o volume total dos movimentos de conversão que conflitam geometricamente com o movimento de conversão (opção automática) ou o volume dos movimentos de conversão especificados pelo usuário no Tabela de Movimentos de Conversão Conflitantes do Modelo Estático no editor de Nós, ou no Tabela da aba Conflitos a partir do supernó.
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 da Função de Custo¶
As funções TPF, JDF e VDF estão sujeitas a certas restrições que acionarão erros e o cancelamento de simulações dinâmicas, atribuições estáticas e ajustes estáticos.
Essas restrições são as seguintes.
- um custo de movimento de conversão (soma de TPF + JDF) deve ser > = 0
- um custo de seção (VDF) deve ser > 0
- uma conexão unidirecional de centroide (VDF) deve ser > = 0 (conexões de veículos, de e para seções ou nós)
- uma conexão bidirecional de centroide (VDF) deve ser > 0 (conexões de transporte público para passageiros, de e para paradas de transporte público)
- um custo de trajetória de supernó (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 serão exibidas na janela Log.
Componentes da Função¶
Componentes de Função são usados para obter saídas adicionais de Atribuições Estáticas ou Simulações Dinâmicas de Tráfego para Sections, Connections e Turns e também para estatísticas de Path.
Se a definição de uma VDF, TPF, JDF ou DCF contiver uma subfunção como parte de seu cálculo, então essa subfunção pode ser declarada como um Function Component e sua saída exibida nas estatísticas do objeto ao qual a função está atribuída. Além disso, também serão calculadas estatísticas de caminho para cada componente.
Por exemplo, se um JDF foi 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 de interseção do movimento de conversão; então essa subfunção pode ser declarada como um Function Component, identificando-a pelo nome 'calculateJDFAttr'.
Exemplo de 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, context.getUserClass())+manager.getUserDefinedCostWeight()*section.getUserDefinedCost()
return turncost
Observe que a função principal não necessariamente chama a subfunção.
No editor de Componente de Função, o String da Função deve corresponder exatamente ao nome da subfunção correspondente e ao Nome será usado como o nome da nova coluna que será gerada.

O código correspondente à subfunção será avaliado separadamente e uma nova coluna para o objeto será criada contendo os valores que ela calcula. Como o Function Component é chamado separadamente, a subfunção deve ter exatamente os mesmos argumentos que a função principal para ser avaliada corretamente.
O Function Component pode ser visualizado na série temporal 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 Atribuição de Caminhos pasta.

Componentes de Função Derivados também podem ser declarados e são calculados como a combinação de outros componentes. Por exemplo, se existirem um componente de tempo de viagem e um componente de distância, a velocidade pode ser calculada sem declarar uma função de velocidade na 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 Derivado implica uma diferença importante de cálculo: definir a velocidade como um componente derivado fornecerá a velocidade média do caminho (distância do caminho dividida pelo tempo de viagem do caminho, depois que esses dois valores tiverem sido calculados), enquanto definir a velocidade por meio de subfunções como um componente de função não derivado somaria as velocidades ao longo do caminho para calcular o valor do caminho para esta coluna.
Em caso de valor inválido como entrada em uma Função Derivada para um intervalo, a Série Temporal mostra NaN. O mesmo para uma divisão por zero. Se todos os intervalos forem inválidos, a função derivada não será incluída.

Funções de Escolha Discreta Estocástica¶
A função Stochastic Discrete Choice é usada para calcular as probabilidades de cada caminho estar sendo usado. Esta função é considerada ao realizar uma Stochastic Traffic Assignment. Para obter mais informações sobre SDCs e seu papel na atribuição, consulte o Alocação Estática de Tráfego informações.
Assinatura:
sdc( context, pathChoice ) -> double
em que:
- contexto e pathChoice são objetos Python do seguinte tipo: 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 Adjustment Weight é usada para atribuir pesos diferentes (não fixos) às contagens (à diferença entre contagens e volumes atribuídos) no processo de ajuste. Ela retorna um valor que multiplica o Confiabilidades previamente definido pelo usuário (1 por padrão). Esta função é levada em conta ao fazer uma Ajuste OD. Esta função é aplicada aos valores dos dados de detectores para seções, detectores e movimentos de conversão, mas não aos valores adicionais de comparação de Exit/Entrances para os quais Confiabilidades pode ser definido no Centroides e Seções aba.
Assinatura:
adw( context, observed ) -> double
em que:
- observado é um double.
observado é o valor na Time Series usada no Adjustment, 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 no Transporte Público¶
A função Transit Waiting Time é usada para modelar o tempo de espera em uma Parada de transporte público até embarcar em um veículo. Esta função é usada ao realizar uma Alocação de Transporte Público. A função de tempo de espera padrão é descrita no Alocação de Transporte Público seção.
Assinatura:
pwf( context, interval ) -> double
em que:
- contexto é um objeto Python do tipo GKFunctionCostContext e intervalo é um double.
contexto fornece o contexto do experimento e intervalo é o headway médio combinado entre chegadas de veículos de transporte coletivo das possíveis linhas 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 em Transporte Público¶
A função Transit Boarding é usada para modelar o custo de embarque em um veículo de transporte coletivo em uma Parada de transporte público, isto é, a tarifa de acesso. Esta função é usada ao realizar uma Alocação de Transporte Público.
Assinatura:
pbf( context, line, stop ) -> double
em que:
- contexto, linha, e parada são objetos Python do seguinte tipo: GKFunctionCostContext, PTLine, e PTStop.
contexto fornece o contexto do experimento. linha é a linha de transporte público na qual o passageiro deseja embarcar. parada é a parada na qual o passageiro está esperando para embarcar.-Estas listas estão confusas e fora do padrão em comparação com as outras funções. Talvez organizar?
Exemplo¶
def pbf(context, line, stop):
res = line.getBoardingFare()
return res
Funções de Tarifa por Distância no Transporte Público¶
A função Tarifa por Distância do Transporte Público é usada para modelar a tarifa por distância/dentro do veículo em uma viagem de Transporte Público em uma Linha de Transporte Público. Esta função é usada ao realizar um Alocação de Transporte Público.
Assinatura:
pff( context, line, transitsegment ) -> double
em que:
- contexto, linha, e transitsegment são objetos Python do seguinte tipo: GKFunctionCostContext, PTLine, e PTSection.
contexto fornece o contexto do experimento. linha é a linha de transporte público na qual o passageiro deseja embarcar. transitsegment é o conjunto de segmentos/seções de uma Parada de Transporte Público até a próxima 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 Coletivo¶
A função Transit Delay é usada para modelar o tempo de viagem ou o custo em um segmento de transporte público em uma Linha de Transporte Público usando o tempo dentro do veículo. Esta função é usada ao realizar uma Alocação de Transporte Público.
Assinatura:
pdf( context, line, transitsegment ) -> double
em que:
- contexto, linha, e transitsegment são objetos Python do seguinte tipo: GKFunctionCostContext, PTLine, e PTSection.
contexto fornece o contexto do experimento. linha é a Linha de Transporte Público. transitsegment é o conjunto de segmentos/seções de uma Parada de Transporte Público até a próxima que está sendo avaliada.
Exemplo¶
A função de atraso padrão, aplicada onde não houver uma função definida pelo usuário, é:
def pdf( context, line, transitsegment ):
distance = transitsegment.getDistance() / 1000.0
# Constant speed 20 km/h
speed = 20.0 / 60.0
delay = distance / speed
# Return value in minutes
return delay
Funções de Penalidade de Transferência de Transporte Público¶
A função Transit Transfer Penalty é usada para modelar a penalidade por transferências de linha para linha durante uma viagem de transporte público. Esta função é usada ao realizar uma Alocação de Transporte Público e ele é selecionado no Editor de experimento. Normalmente as pessoas evitam transferências no transporte coletivo devido ao inconveniente que elas produzem; portanto, esta função penalizará a decisão de fazer uma transferência.
Assinatura:
ptp( context ) -> double
em que:
- contexto é um objeto Python do tipo GKFunctionCostContext e fornece o contexto do experimento.
Exemplo¶
def ptp( context ):
res = 7.0
# minutes
return res
Funções de Caminhada Exclusiva do Transporte Público¶
A função Transit Transfer Walking-Only é usada para modelar o custo da conexão da origem ao destino durante uma viagem de alocação de transporte coletivo, assumindo que ela seja feita a pé. Esta função é usada ao realizar uma Alocação de Transporte Público e ele é selecionado no Editor de experimento. Há situações em que o custo de usar Transporte Público é alto demais para os viajantes. Essa função pode ser usada para determinar o custo máximo que os viajantes aceitarão para usar Transporte Público, acima do qual descartarão essa opção e farão a viagem apenas a pé.
Assinatura:
wof( context, fromConnector, toConnector ) -> double
em que:
- contexto é um objeto Python do tipo GKFunctionCostContext e fornece o contexto do experimento.
- fromConnector é um objeto Python do tipo PTCentroidConnector que fornece a conexão do centroide de origem usada na viagem.
- toConnector é um objeto Python do tipo PTCentroidConnector que fornece a conexão do Centroide de destino usada na viagem.
Exemplo Básico¶
def wof( context, fromConnector, toConnector ):
walkingSpeed = 6.0 * 1000 / 60 # 6 km/h -> m/minminutes
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 exclusivamente a pé. Por exemplo, se duas áreas estão conectadas de forma esparsa devido a um obstáculo (rodovia, rio, ... modelado como uma GKPolyLine), é improvável que o caminho exclusivamente a pé seja apenas uma linha reta, mas sim que faça um desvio para encontrar uma ponte (GKSection) para atravessar. Nesses casos, se os segmentos de viagem origem - parada ou parada - destino intersectarem qualquer obstáculo, teremos que considerar o desvio adicional para atravessar 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/minminutes
bridgesGroup = model.getCatalog().findByName("Bridges")
res = 0.0
if requiresBridge(centroid,stop):
minimumPenalty = float('inf')
#Find closest bridge to cross
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/minminutes
res = 0.0
res += fromConnector.getMaster().length3D()/walkingSpeed
res += toConnector.getMaster().length3D()/walkingSpeed
# Additional cost due to bridge detour
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 Desconforto por Lotação¶
A função Crowding Discomfort é uma função não decrescente usada para modelar o desconforto gerado por compartilhar um espaço limitado ao usar transporte público com outros passageiros. Esta função é usada ao realizar uma Alocação de Transporte Público e ele é selecionado no editor de Linha de Transporte Público. Ele avalia o desconforto com base em quão congestionada está a fila nesse segmento e por quanto tempo os passageiros permanecem nesse segmento.
Assinatura:
pcd( context, line, volume, delay ) -> double
em que:
- 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 Público.
- volume é um double que fornece o volume que viaja de uma Transit Stop para a próxima Transit Stop usando a Transit Line linha.
- atraso é um double que fornece o tempo de atraso de uma Transit Stop para a próxima Transit Stop usando a Transit Line 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 Parada do Transporte Coletivo¶
A função Transit Dwell Time é usada para modelar o tempo de permanência de veículos de transporte público nas paradas, levando em conta o volume de passageiros embarcando e desembarcando durante a atribuição. Use esta função ao realizar uma estática Alocação de Transporte Público.
Assinatura:
pdt( context, line, transitstop, alightingVolume, boardingVolume ) -> double
em que:
- 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 Público.
- ptstop é um objeto Python do tipo PTStop que fornece a Parada de Transporte Público.
- alightingVolume fornece o volume agregado de passageiros desembarcando no ponto de transporte coletivo a partir da linha de transporte coletivo durante todo o período de alocação.
- boardingVolume fornece o volume agregado de passageiros embarcando na parada de transporte público a partir da linha de transporte público durante todo o período de alocaçã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 Distribution Impedance calcula a impedância combinada dos modos disponíveis. Esta função é executada dentro do processo de Distribution e é selecionada na Distribution and Modal Split Area.
Assinatura:
dif( context, origin, destination, modes, data ) -> double
em que:
- contexto (GKFunctionCostContext) fornece o contexto do experimento.
- origem (GKCentroid) é o centroide de origem.
- destino (GKCentroid) é o centroide de destino.
- modos (vetor de GKTransportationMode) são os modos disponíveis e combináveis para o cálculo de impedância combinada.
- data (SkimDataProvider) dá acesso aos valores de skim e estacionamento.
Exemplo¶
\# Distribution Impedance Function
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 Impedância de Distribuição¶
A função Distribution Deterrence calcula a interatividade do centroide em função da impedância. Esta função é executada dentro do processo Gravity Model Distribution e pode ser definida no Gravity Model Distribution Experiment.
Assinatura:
ddf( context, cost ) -> double
em que:
- contexto (GKFunctionCostContext) fornece o contexto do experimento.
- cost (double) é o custo ou impedância.
Exemplo¶
\# Distribution Deterrence Function
def ddf( context, cost ):
return 1.0 / cost
Funções de Utilidade de Distribuição¶
A função Distribution Utility calcula a utilidade de todas as opções de viagem a partir de uma origem ou para um destino. Esta função é executada dentro do Distribuição de escolha de destino processo e pode ser definido no Experimento de Distribuição de Destino.
Assinatura:
duf( context, data, modes, centroid, centroids ) -> double
em que:
- contexto (GKFunctionCostContext) fornece o contexto do experimento.
- data (SkimDataProvider) dá acesso a matrizes skim.
- modos (vetor de GKTransportationMode) são os modos disponíveis e combináveis para o cálculo da utilidade.
- centroide (GKCentroid) é o centroide de origem ou destino em consideração.
- centroides (vetor de GKCentroid) são os centroides disponíveis a partir do centroide em consideração.
Exemplo¶
\# Distribution Utility Function
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
Funções de Utilidade de Divisão Modal¶
A função de Utilidade de Divisão Modal calcula o valor de utilidade por modo de transporte para cada par OD. Esta 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
em que:
contexto: Uma instância de um GKFunctionCostContext, fornece o contexto do experimento. origem: Uma instância de um GKCentroid, o centroide de origem. destino: Uma instância de um GKCentroid, o centroide de destino. modo: O modo de transporte. data: Uma instância de um SkimDataProvider, dá acesso aos valores de skim e estacionamento.
Exemplo¶
\# Modal split utility function
from PyLandUsePlugin import *
def msu( context, origin, destination, mode, data ):
c1 = -1.0
c2 = -1.5
res = c1 * data.getSkimValue( SkimType.eCost, mode, origin, destination )
res += c2 * data.getSkimValue( SkimType.eDistance, mode, origin, destination )
return res
Funções de Escolha Discreta de Divisão Modal¶
A função de Escolha Discreta de Divisão Modal calcula a probabilidade de cada modo de escolha como uma função da utilidade. Esta função é executada dentro do processo de Divisão Modal e pode ser definida no Experimento de Divisão Modal.
Assinatura:
def mcf( context, vehicles, utilities ):
em que:
contexto (GKFunctionCostContext) fornece o contexto do experimento. veículos (vetor de GKVehicle) são os veículos pertencentes aos modos de transporte disponíveis correspondentes. utilitários (vetor de double) fornece os valores de utilidade para cada modo (veículo).
Exemplo¶
\# Modal Split Discrete Choice Function
from math import exp
from PyLandUsePlugin import *
def mcf( context, vehicles, utilities ):
res = []
total = 0.0
for utility in utilities:
if utility!=0:
total = total + exp( utility )
for i in range( 0, len(modes) ):
if utilities[i]!=0:
res.append( exp( utilities[i ] ) / total )
else:
res.append( 0.0 )
return res
Funções do Modelo de Disponibilidade de Automóvel¶
A função Car Availability Model é usada para calcular automaticamente o Disponibilidade de Automóvel e Não Disponibilidade de Automóvel percentuais por zona para o Geração/Atração procedimento.
Assinatura:
cam( centroidData, purpose, modelConnection ) -> double
em que:
- centroidData, propósito, e modelConnection são objetos Python do seguinte tipo: CentroidGenerationAttractionData, GKTripPurpose, e GKModelConnection.
centroidData dá acesso aos dados de Disponibilidade de Automóvel (Tamanho Médio do Domicílio e Posse de Automóvel (por 1000 hab)) . propósito é o Finalidade da Viagem sendo avaliado, que contém alguns parâmetros relacionados à disponibilidade de carro. modelConnection fornece as informações necessárias para determinar as substituições da rede que se aplicam.
Exemplo¶
def cam( centroidData, purpose, modelConnection ):
carAvailability = 100.0
return carAvailability
Funções de Park and Ride¶
O Ação de Tráfego Park and Ride altera o centroide de destino de um veículo em resposta ao congestionamento. O veículo pode escolher viajar para um centroide diferente, a partir do qual o viajante prosseguirá por transporte público. A função Park and Ride retorna o custo percebido geral de usar o transporte público e pode levar em conta o valor do tempo do veículo e as percepções relativas do tempo de viagem em um carro e em um ônibus, bem como o custo de estacionamento. Veja o Atributos do centroide Park and Ride para obter informações sobre como definir a função park and ride, e o preço e a capacidade do centroide park and ride, que podem ser usados como entrada para a função Park and Ride.
Assinatura:
def par( context, manager, centroid, vot, travelTime, travelTimeTransit )
em que:
- contexto é um GKFunctionCostContext objeto Python.
- gerenciador é um DTAManager objeto Python.
- centroide é o centroide park and ride, um DTACentroid objeto Python.
- vot é do veículo Valor do Tempo
- tempo de viagem é o tempo esperado da viagem nas circunstâncias atuais (da seção onde o park and ride é avaliado até o destino original).
- traveltimePT é o tempo esperado da viagem usando Transit (do estacionamento de park and ride até o destino original em Transit).
Exemplo¶
def par ( context, manager, centroid, vot, travelTime, travelTimeTransit ):
cost = TravelTimePT + 1.5 * centroid.getDataValueDoubleByID( centroid.parkAndRidePriceAtt )
return cost
Funções de Penalidade de Chegada para Reprogramação Dinâmica do Horário de Partida OD¶
As funções de penalidade implementam o custo de programação de chegar adiantado ou atrasado. Este é o custo extra a ser adicionado ao custo de viagem como resultado de chegar adiantado ou atrasado; o processo de ajuste então minimiza os custos globais para todos os viajantes.
Para criar uma função de custo de programação, use o editor de funções para editar uma nova função e rotulá-la como uma Função de Penalidade de Chegada para Reprogramação Dinâmica do Horário de Partida OD. A função padrão é uma combinação de uma função linear e uma exponencial para penalizar progressivamente discrepâncias maiores no horário de chegada.
Assinatura:
def apf( context, tt, interval )
em que:
- contexto é um GKFunctionCostContext objeto.
- tt é a diferença no horário de chegada entre a janela de horário de chegada preferida e o horário real, ou seja, o número de segundos adiantado ou atrasado.
- intervalo é o comprimento de uma janela de tempo de chegada ou partida.
A função deve ser programada para usar parâmetros diferentes para cada classe de veículo ou classe de usuário, pois o custo de atraso variará de acordo com o motivo da viagem e a hora do dia. A classe de usuário está disponível no contexto parâmetro para a função.
Exemplo¶
def apf( context, tt, interval ):
coef = 0.8
res = tt*coef
return res
