Pular para o conteúdo

Aimsun Next microSDK

Descrição do microSDK do Aimsun Next

A Plataforma Aimsun Next faz amplo uso do conceito de plug-in, permitindo que componentes externos sejam carregados para estender as funcionalidades da aplicação. O microSDK do Aimsun Next permite a codificação de duas classes C++, para os modelos de veículo e de simulação usados para substituir o veículo e o comportamento do veículo, e inclui as funções necessárias para registrar o novo modelo de comportamento para substituir o modelo atual de Microssimulação do Aimsun Next. Durante a simulação, o modelo de microssimulação atualiza cada veículo usando o modelo especificado. Cada veículo é uma instância da classe A2SimVehicle ou de uma classe derivada dela. Um modelo é uma instância da A2BehavioralModel ou de uma classe derivada dela.

Um desenvolvedor de Microsimulation do Aimsun Next precisará criar subclasses tanto das classes A2SimVehicle quanto A2BehavioralModel. O plug-in gerado pelo projeto microSDK é então registrado usando um arquivo XML (veja abaixo) copiado para a pasta "plugins" encontrada dentro do diretório de instalação do Aimsun Next.

A Classe A2SimVehicle

Esta classe contém todos os dados relevantes do veículo, métodos para acessá-los e métodos para atualizar o veículo a cada passo da simulação. Estes são organizados em cinco categorias, descritas abaixo.

Construtor

simVehicleParticular ( void * handlerVehicle, unsigned short idhandler, bool isFictitiousVeh, unsigned int vehTypeId = 0 );

O construtor do veículo, que normalmente é chamado a partir da função do modelo comportamental chamada "arrivalNewVehicle". Os dados internos do veículo estão sendo processados pelo Aimsun e não estão prontos para uso; portanto, não tente usar outras funções dentro do construtor para acessar dados (funções get). Se você precisar acessar colunas GKVehicle para recuperar atributos personalizados, use o vehTypeId fornecido, conforme mostrado no exemplo de código.

bool **isFictitious**() const;

Retorna se o veículo é real ou fictício (sombra de mudança de faixa, incidentes, yield, parada, semáforos).

bool **isTrafficLight**() const;

Retorna se o veículo é um semáforo (os semáforos são simulados com veículos fictícios parados para garantir que os veículos simulados parem da mesma forma que fariam ao entrar em uma fila)

int **getId**() const;

Retorna o ID do veículo, 0 se for Fictício e > 0 caso contrário.

unsigned int **getVehType**() const;

Retorna o ID do tipo de veículo.

double **getAcceleration**( ) const;

Aceleração máxima do veículo conforme especificado no tipo de veículo, considerando variações locais.

double **getDeceleration**( ) const;

Desaceleração normal do veículo conforme definida no tipo de veículo, considerando variações locais.

double **getDecelerationMax**( ) const;

Desaceleração máxima do veículo conforme definida no tipo de veículo.

double **getEstimationOfLeadersDeceleration**(A2SimVehicle *leader, double LeaderSpeed) const;

Estimativa da desaceleração do líder usada no Modelo de Gipps.

double **getDecelerationVariationFactor**(const bool ImprudentCase)const;

Retorna o fator de desaceleração aceito pelo veículo para o caso de mudança de faixa imprudente

unsigned int **getReactionSteps**() const;

Tempo de reação expresso em número de passos de simulação, considerando variações locais.

double **getReactionTime**() const;

Tempo de reação em segundos considerando variações locais.

double **getReactionTimeAtStop**() const;

Tempo de reação na Parada considerando variações locais.

double **getReactionTimeAtTrafficLight**() const;

Tempo de reação no Semáforo considerando variações locais.

double **getLength**() const;

Comprimento do veículo conforme definido no tipo de veículo.

double **getMinimumDistanceInterVeh**() const;

Espaçamento mínimo à frente do veículo conforme definido no tipo de veículo.

double **getMinimumDistanceInterVeh**(A2SimVehicle *leader) const;

Gap mínimo à frente do veículo, corrigido para o tipo de veículo do líder (0 se for semáforo ou incidente).

double **getFreeFlowSpeed**() const;

Velocidade Máxima Desejada do veículo para a faixa atual.

double **getSensitivityFactor**() const;

Fator de sensibilidade à desaceleração do líder conforme definido no tipo de veículo.

double **getMinimumHeadway**() const;

Headway Mínimo à frente do veículo conforme definido no tipo de veículo.

bool **isUpdated**() const;

Retorna true se o veículo já tiver sido atualizado; caso contrário, false.

double **getPosition**( const unsigned int state) const;

Retorna a posição do veículo no tempo (t – state * simulationStep) (unidades: m) a partir do início da A2KSection atual.

A2KSections são as seções usadas pelo microssimulador. Todas as posições usadas no modelo micro referem-se às A2KSections. 

double **getPositionInGKSection**( const unsigned int state) const;

Retorna a posição do veículo no tempo (t – state * simulationStep) (unidades: m) desde o início da GKSection atual.

As GKSections são as seções fornecidas pela GUI. Se elas contiverem pontos de segmento, poderão ser cortadas em diferentes A2KSections nesses pontos de segmento pelo modelo. 

double **getPositionInTargetlane**( double X,int targetLane) const;

Retorna a posição em targetlane, equivalente a X na faixa atual;

double **getSpeed**( const unsigned int state) const;

Retorna a velocidade do veículo no tempo (t – state * simulationStep) (unidades: m/s).

void **getCoordinates**( double &xfront, double &yfront, double &xback, double &yback) const;

Retorna as coordenadas globais do ponto médio do para-choque dianteiro de um veículo (xfront, yfront) e as coordenadas globais do ponto médio do para-choque traseiro de um veículo (xback, yback).

double **getGap**(A2SimVehicle *vehUp, double ShiftUp, A2SimVehicle * vehDown,double ShiftDw,double &Xup, double &Vup, double &Xdw, double &Vdw,int time=1)const;

Retorna o Gap entre vehUp e vehDown, sua posição e velocidades no tempo t=t-RTup, t se time=0 ou t+dt se time=-1

double **getPositionReferenceVeh**( const unsigned int state, A2SimVehicle *vehReference, const unsigned stateVehRef) const;

Esta função funciona apenas para veículos não fictícios. Ela será descontinuada e a função getGap deverá ser usada em seu lugar

Obtém a posição do veículo no tempo (t - state * simulationStep), tomando o veículo de referência vehReference(units: m). O veículo e o veículo de referência não precisam estar na mesma seção, nem na mesma faixa, embora a saída não leve em conta a diferença de comprimento entre as seções, mas apenas ao longo delas. Se não estiverem localizados na mesma seção, a função retorna a menor distância entre as frentes dos dois veículos.

unsigned int **getIdCurrentLane**() const;

Retorna o índice da faixa atual do veículo, sendo 1 a faixa mais à direita da seção.

unsigned int **getIdCurrentSection**() const;

Retorna o índice da seção atual do veículo, ou da próxima seção se o veículo estiver em um nó.

unsigned int **getIdNextSection**() const;

Retorna o índice da próxima seção do veículo.

unsigned int **getIdNextJunction**() const;

Retorna o índice da próxima interseção do veículo, ou da interseção atual se o veículo estiver em um nó. Se a próxima interseção for uma junção (nó muito curto que não contém nenhuma entidade), a função retorna -1.

unsigned int **getIdNextTurning**() const;

Retorna o índice do próximo movimento de conversão do veículo, ou do movimento de conversão atual se o veículo estiver em um nó. Se o próximo nó for uma junção (nó muito curto que não contém nenhuma entidade), a função retorna -1.

bool **isInAReservedLane**() const;

Retorna se o veículo está em uma faixa reservada ou não

int **getNumberOfMainLanesInCurrentSection**() const;

Retorna o número de faixas da seção atual do veículo sem levar em conta as faixas laterais.

int **getNumberOfLanesInCurrentSection**() const;

Retorna o número total de faixas da seção atual do veículo.

int **getNumberOfMainLanesInNextSection**() const;

Retorna o número de faixas da próxima seção do veículo, sem levar em conta as faixas laterais.

int **getNumberOfLanesInNextSection**() const;

Retorna o número total de faixas da próxima seção do veículo.

bool **IsLaneOnRamp**(int targetlane) const;

Retorna true se targetLane (-1 é esquerda, 0 atual e 1 é direita) for uma faixa lateral de entrada.

bool **isCurrentLaneInNode**() const;

Retorna true se a faixa atual estiver dentro de um nó.

double **getDensity**(const int targetLane) const;

Retorna a densidade dentro da targetLane (-1 é esquerda, 0 é atual, 1 é direita) em veh/m.

double **getLaneDensity**(const int lane) const;

Retorna a densidade dentro da faixa (1 é a faixa mais à direita da seção) em veh/m.

int **getNumberOfVehiclesStoppedInLane**(const int lane) const;

Retorna o número de veículos com speed=0 dentro da faixa (1 é a faixa mais à direita da seção) em veh/m.

double **getAverageSpeedAHead**(const int targetLane, const double maximumDist, const int maximumNbVehs) const;

Retorna a velocidade média dos primeiros maximumNbVehs veículos localizados dentro de maximumDist (metros) na targetlane (-1 é à esquerda, 0 é a atual, 1 é à direita) em m/s.

double **getAverageLaneSpeedAHead**(const int ordenCarril, double maximumDist, int maximumNbVehs) const;

Retorna a velocidade média dos primeiros maximumNbVehs veículos localizados dentro de maximumDist (metros) dentro da faixa (1 é a faixa mais à direita da seção) em m/s.

void **setNextSection**(int idNextSection) const;

Define a próxima seção do veículo (deve ser chamada antes de entrar no nó).

void **setTargetLaneInDownStreamSection**(int idNextSection, int nextTargetLane) const;

Define a próxima faixa e a próxima seção do veículo (precisa ser chamado antes de entrar no nó).

enum Type {eNone, eReservedLane, eTurning, eNotAllowedInfluence,eNotAllowed, ePTStopInfluence, eOnRamp, eLaneClosureInfluence,eIncidentInfluence, eLaneClosure, eIncident, ePTStop};

int **getObstacleType**() const;

Obtém o tipo de Obstacle presente na faixa atual. Usa o tipo enumerado para retornar o tipo de obstáculo.

int **getObstacleTypeInLane**(const int lane) const;

Obtém o tipo de Obstacle presente na faixa (1 é a faixa mais à direita).

double **getDistance2Obstacle**() const;

Obtém a distância até o próximo Obstacle presente na faixa atual.

double **getDistance2ObstacleInLane**(const int lane) const;

Obtém a distância até o próximo Obstacle presente na faixa (1 é a faixa mais à direita).

double **getDistanceOfInfluenceOfObstacleInLane**(const int ordenCarril) const;

Obtém a distância de influência até o próximo Obstacle presente na faixa (1 é a faixa mais à direita).

int **getNbLaneChanges2ReachNextValidLane**() const;

Obtém o número de mudanças de faixa a serem feitas para alcançar uma faixa válida (> 0 significa direita)

A2SimVehicle * **getLeader**(double &Shift) const;

Retorna o líder atual (que pode ser fictício) e seu deslocamento. Shift é o deslocamento entre o início da seção do veículo e o início da seção do líder. Como o líder está a jusante, ele é ≥ 0.

A2SimVehicle * getReflectedVehicle() const;

Retorna o veículo refletido por um Nexo ou um Conflito. maxDist serve como uma ferramenta para definir uma distância de visibilidade personalizada para a busca. Não usar maxDist (valor negativo) fará com que o algoritmo use o padrão para Gipps.

    A2SimVehicle * **getRealLeader**(double &Shift, double maxDist = -1) const;

Retorna o líder atual (não fictício) e seu deslocamento.

A2SimVehicle * getCooperationLeader(double &Shift) const;

Retorna o líder de cooperação e seu deslocamento.

A2SimVehicle * getTargetGapLeader (double &Shift) const;

Retorna o líder de cooperação e seu deslocamento.

bool hasSimpleLeader() const;

Retorna se a condição líder mais restritiva do veículo é outro veículo normal (simples) ou qualquer outra condição viária (complexa), como linhas de retenção, conflitos, obstáculos e similares. A condição de infinito (não ter líder) é considerada simples e retornaria true.

A2SimVehicle * **getFollower**(double &Shift) const;

Retorna o seguidor atual (que pode ser fictício) e seu deslocamento. Shift é o deslocamento entre o início da seção do veículo e o início da seção do seguidor. Como o seguidor está a montante, ele é ≤ 0.

A2SimVehicle * **getRealFollower**(double &Shift) const;

Retorna o seguidor atual (não fictício) e seu deslocamento.

void **getUpDown**(int targetlane, double shiftPos, A2SimVehicle *&vehUp, double &shiftUp, A2SimVehicle *&vehDown, double &shiftDown ) const;

Retorna os veículos atuais acima e abaixo (podem ser fictícios) e seus offsets na targetlane (-1 é à esquerda, 0 atual e 1 é à direita).

void **getRealUpDown**(int targetlane, double shiftPos, A2SimVehicle *&vehUpReal, double &shiftUp, A2SimVehicle *&vehDownReal, double &shiftDown) const;

Retorna os veículos atuais a montante e a jusante (podem ser fictícios) e seus deslocamentos (não fictícios) na targetlane (-1 é esquerda, 0 atual e 1 é direita).

bool isCooperating() const;

Retorna se o veículo está cooperando com outro veículo para criar uma brecha para que ele faça uma mudança de faixa.

bool isTargetingGap() const;

Retorna se o veículo está mirando uma brecha em outra faixa, o que significa que outro veículo está cooperando com ele para permitir que ele faça uma mudança de faixa.

bool **hasMandatorySpeed**() const;

Retorna se o veículo foi configurado pela API para ter uma velocidade definida obrigatória.

bool **hasModifiedSpeed**() const;

Retorna se o veículo foi configurado pela API para considerar usar uma velocidade definida se as condições permitirem

double **getAPISpeed**() const;

Retorna a velocidade atribuída ao veículo pela API, obrigatória ou modificada; retorna valor negativo se nenhuma velocidade tiver sido definida

bool **applyAimsunCarFollowingModel**()const;

Aplica o modelo padrão de seguimento veicular para este veículo.

double **getAimsunCarFollowingSpeed**() const;

Calcula a velocidade padrão de car following para este veículo.

double **getAccelerationComponentGippsModelSpeed**() const;

Calcula o componente padrão de velocidade de aceleração para este veículo com suas características atuais.

double **getAccelerationComponentGippsModelSpeed**(double CurrentSpeed ,double TargetSpeed,double deltaRT) const;

Calcula o componente de velocidade de aceleração para este veículo e os valores de entrada especificados.

double **getDecelerationComponentGippsModelSpeed**(double Distance2Obstacle) const;

Calcula o componente padrão de velocidade de desaceleração para este veículo imposto por um obstáculo parado localizado a uma Distance2Obstacle do veículo.

double **getDecelerationComponentGippsModelSpeed**(const A2SimVehicle *Leader,double ShiftPre,bool controlDecelMax,bool aside,int time) const;

Calcula o componente padrão de velocidade de desaceleração para este veículo imposto pelo veículo Leader com deslocamento ShiftPre, onde: .

  • controlDecelMax limita o resultado para que seja compatível com as capacidades de frenagem
  • à parte usa uma implementação especial que permite uma adaptação mais suave em caso de gaps negativos se o Leader estiver localizado em uma faixa diferente.
  • tempo (normalmente definido como 1), pode ser definido como 0 se forem necessárias previsões para o tempo t+RT.
bool **applyAimsunLaneChangingModel**()const;

Aplica o modelo padrão de mudança de faixa para este veículo.

bool **isLaneChangingPossible**(int targetLane) const;

Retorna se a mudança de faixa é possível em direção à targetlane (-1 é esquerda, 0 atual e 1 é direita). Verifica: ausência de linha contínua e se o veículo não está atualmente mudando de faixa.

bool **isGapAcceptable**(int targetlane,double XposInpEntObj,const A2SimVehicle *pVehUp,double ShiftUp,const A2SimVehicle *pVehDw,double ShiftDw)const;

Retorna se o gap entre pVehUp e pVehDw é aceitável de acordo com os valores de CarFollowingDecelerationComponentSpeed().

void **assignAcceptedGap**(int targetlane,double XPosInpEntObj,const A2SimVehicle *vehUp,double ShiftUp,const A2SimVehicle *vehDown,double ShiftDw,int threadId) const;

Coloca o veículo na lista de veículos para mudar de faixa, deixando que os algoritmos do Aimsun decidam se isso é possível em termos de prioridade em relação a outros veículos que desejam mudar de faixa.

void **targetNewGap**(int targetlane, double XPosInpEntObj, const A2SimVehicle *vehUpReal, double ShiftUp, const A2SimVehicle *vehDownReal, double ShiftDw, int threadId)const;

Procura uma nova brecha-alvo para cooperação em torno da brecha entre vehUp e vehDown. 

void **assignNewTargetGap** (double XPosInpEntObj,const A2SimVehicle *vehUpReal,double ShiftUp,const A2SimVehicle *vehDownReal,double ShiftDw,int threadId) const;

Coloca o veículo na lista de veículos que têm como alvo a brecha entre vehUp e vehDown (vehUp cooperará dependendo dos parâmetros de cooperação), deixando que os algoritmos padrão do Aimsun decidam se isso é possível em termos de prioridade em relação a outros veículos que desejam atingir a mesma brecha.

void **applyLaneChanging**(const int targetlane, int threadId)const;

Executa a Mudança de Faixa em direção a targetlane. Esta função inclui a aceitação de brecha. 

void **setAsCourtesyVehicle**(const A2SimVehicle *veh2Yield, double ShiftVeh2Yield, int threadId);

Força o veículo atual a cooperar com veh2Yield. ShiftVeh2Yield é o deslocamento entre o início da seção do veículo e o início da seção do líder. Como o veh2Yield está a jusante, ele é ≥ 0.

Classe A2BehaviouralModel

O objetivo desta classe é atualizar todos os veículos a cada passo de simulação. Alguns de seus métodos virtuais podem ser reescritos para atender aos seguintes requisitos:

arrivalNewVehicle

Essa função cria um novo veículo. Normalmente, esse método retornará não uma instância de A2SimVehicle, mas uma instância de uma subclasse dessa classe. Esse método é chamado cada vez que um novo veículo é gerado; seja quando um veículo real é gerado pouco antes de entrar na rede ou na fila virtual; ou quando um veículo fictício é criado durante a simulação, como um veículo de conflito ou nexo.

removedVehicle

Esta função exclui um veículo. Este método é chamado cada vez que um veículo é removido do modelo; seja quando um veículo real sai da rede; ou quando um veículo fictício é removido durante a simulação, como veículos de conflito ou nexo.

evaluateLaneChanging

Este método permite a reimplementação de uma lógica de Lane-Changing completamente nova e deve retornar um bool definido como true se o veículo a estiver usando e false se o veículo estiver usando o método padrão de mudança de faixa. As funções de veículo que podem ser usadas neste método incluem:

  • isLaneChangingPossible
  • isGapAcceptable
  • setAsCourtesyVehicle
  • applyLaneChanging
  • assignAcceptedGap
  • applyAimsunLaneChangingModel

Este método é chamado uma vez por passo de simulação para cada veículo. Ele é chamado depois que cada veículo identificou seu líder; antes que qualquer veículo mude de faixa e antes do método de car following.

evaluateCarFollowing

Este método permite a reimplementação de uma lógica de Car-Following totalmente nova e deve retornar um bool definido como true se o veículo a estiver usando e false se o veículo estiver usando o método padrão de car following do Aimsun. As saídas desta função são a nova velocidade e a nova posição do veículo. As funções de veículo que podem ser usadas neste método incluem:

  • getAimsunCarFollowingSpeed
  • getAccelerationComponentGippsModelSpeed
  • getDecelerationComponentGippsModelSpeed
  • applyAimsunCarFollowingModel

Este método é chamado depois que todos os veículos mudaram de faixa e identificaram seu (novo) líder; antes que qualquer veículo tenha atualizado velocidade e posição.

Uma alternativa à implementação de métodos completos de car-following e/ou mudança de faixa consiste em modificar as expressões-chave usadas nos métodos de car-following e lane-changing do Aimsun Next, especificamente os componentes de velocidade de aceleração e desaceleração e o intervalo mínimo usado na aceitação de brechas. A implementação padrão é mostrada como exemplo.

computeCarFollowingAccelerationComponentSpeed

Este método e o correspondente computeCarFollowingDecelerationComponentSpeed método sobrescreve as expressões do modelo de Gipps durante toda a simulação (afetando o car following, mas também a motivação para mudança de faixa e a aceitação de gaps).

O computeCarFollowingAccelerationComponentSpeed método pode ser chamado muitas vezes por passo de simulação para cada veículo, com diferentes valores de entrada quando:

  • O veículo escolhe a próxima conexão que irá tomar.
  • O veículo está envolvido em um cálculo de preferência, sendo o veículo prioritário ou o veículo que cede passagem.
  • O veículo estima se pode acelerar em um espaço à frente para realizar a mudança de faixa.
  • O veículo está avaliando sua nova velocidade com restrições de sua seção atual.
  • O veículo está avaliando sua nova velocidade com restrições do movimento de conversão seguinte.

O computeCarFollowingDecelerationComponentSpeed método pode ser chamado muitas vezes por passos de simulação para cada veículo com diferentes valores de entrada quando:

  • Quando o veículo está prestes a entrar, para verificar se ele pode entrar atrás do último veículo presente na faixa.
  • O veículo seleciona a próxima conexão que vai usar.
  • Para verificar qual líder potencial é o mais restritivo durante a avaliação de líder na faixa atual ou na faixa-alvo.
  • To Vehicle está avaliando sua nova velocidade levando em conta diferentes tipos de líderes, como líder atual, BusStop, Obstacles, Priority Vehicle, Cooperation leader, Off ramp leader…

computeMinimumGap

Este método sobrescreve o critério minimumGap para Gap Acceptance em toda a simulação. Ele é chamado quando o veículo está tentando mudar de faixa e avalia os espaçamentos mínimos necessários em relação aos veículos a montante e a jusante localizados na faixa de destino. Ele também é chamado quando o veículo avalia se pode se adaptar a um veículo que solicita cooperação e para calcular a velocidade atrás de um líder localizado em uma faixa adjacente.

isVehicleGivingWay

Este método sobrescreve o modelo de aceitação de brecha em cedências de prioridade. Ele é chamado para cada par de veículo que cede passagem e veículo potencialmente prioritário envolvido em uma cedência. O modelo de cedência é executado antes dos modelos de mudança de faixa e de seguimento veicular.

avoidCollision

Este método é chamado uma vez por veículo e por passo de simulação, depois que todos os veículos tiverem sido atualizados. A ação padrão (obtida retornando false) é mover para trás os veículos que se sobreporiam ao veículo precedente.

Métodos de Simulação

virtual double **getSimStep**();

Retorna o passo de simulação.

virtual A2SimVehicle * **arrivalNewVehicle**( void *handlerVehicle, unsigned short idHandler, bool isFictitiousVeh, unsigned int vehTypeId) = 0;

Insere um novo veículo no modelo externo

virtual void removedVehicle( void *handlerVehicle, unsigned short idHandler, A2SimVehicle * a2simVeh ) = 0;

Remove um veículo do modelo externo.

virtual bool **evaluateLaneChanging**( A2SimVehicle *vehicle ) = 0;

Avalia a nova faixa e a ordem do veículo.

virtual bool **evaluateCarFollowing**(A2SimVehicle *vehicle, double &newpos, double &newspeed) = 0;

Avalia a nova velocidade e posição do veículo.

virtual double **computeCarFollowingAccelerationComponentSpeed**(A2SimVehicle *vehicle, double VelActual, double VelDeseada, double RestoCiclo)=0;

Calcula a componente de aceleração da velocidade a ser usada em todo o modelo.

virtual double **computeCarFollowingDecelerationComponentSpeed**(A2SimVehicle *vehicle, double Shift, A2SimVehicle *vehicleLeader, double ShiftLeader,bool controlDecelMax=false, bool aside=false,int time=1)=0;

Calcula o componente de desaceleração da velocidade a ser usado em todo o modelo. Inclui car-following na faixa adjacente (aside).

virtual double **computeCarFollowingDecelerationComponentSpeedCore**(A2SimVehicle *vehicle, double speedVehicle, A2SimVehicle *vehicleLeader, double speedLeader, double gap, double leaderDecelerationEstimated)=0;

Calcula a componente de desaceleração da velocidade a ser usada em todo o modelo.

virtual double **computeMinimumGap** (A2SimVehicle *vehicleUp, A2SimVehicle *vehicleDown,double Xup,double Vup,double Xdw,double Vdw,double Gap,bool ImprudentCase=false, bool VehicleIspVehDw=false)=0;

Calcula o intervalo mínimo necessário entre o veículo a montante e o veículo a jusante para garantir a continuidade.

virtual bool **isVehicleGivingWay**(A2SimVehicle *vehicleGiveWay, A2SimVehicle *vehiclePrioritary, yieldInfo *givewayInfo, int &Yield)=0;

Avalia se o veículo vehicleYield deve parar para evitar colisão com vehiclePrio ou se ele pode prosseguir.

virtual bool **avoidCollision**(A2SimVehicle *vehicle,A2SimVehicle *vehiclePre,double ShiftPre)=0;

Usa as informações sobre o veículo e seu líder e corrige a posição do veículo, se necessário.

virtual int **evaluateLaneSelectionDiscretionary**(A2SimVehicle *vehicle,bool LeftLanePossible,bool RightLanePossible)=0;

Substitui o modelo de seleção de faixa entre faixas válidas se o veículo já estiver na Zona 1.

virtual int **evaluateHasTime2CrossYellowState**(A2SimVehicle *vehicle, double distance2StopLine) = 0;

Chamado quando o comportamento de sinal vermelho foi adicionado (como um veículo parado). Valor de retorno: -1: não avaliado (e o Aimsun Next avaliará o veículo seguindo seu modelo interno), 0: o veículo não tem tempo para cruzar, 1: o veículo tem tempo para cruzar.

The A2BehavioralModelCreator Class

Esta classe criará uma classe de modelo comportamental. O desenvolvedor deve criar uma subclasse dela para retornar um novo modelo.

class A2BehavioralModelCreator{
public:
A2BehavioralModelCreator();
~ A2BehavioralModelCreator();
virtual A2BehavioralModel * newModel() = 0;
};

Registrando um Novo Modelo

O Aimsun Next carrega todos os plug-ins encontrados na pasta de plug-ins, /ProgramFiles/Aimsun/Aimsun Next X.X/plugins/.

Cada plug-in é declarado usando um arquivo XML. O nome não é importante, exceto pelo fato de que o Aimsun Next carrega os plug-ins em ordem alfabética. Por esse motivo, recomenda-se numerar cada plug-in para fixar a ordem de carregamento.

O XML contém as seguintes tags:

<plugin>
    &lt;name&gt;MyModel</name&gt;
    &lt;lib&gt;mymodel</lib&gt;
&lt;/plugin&gt;

Onde name é o nome exclusivo do plug-in usando caracteres ASCII e lib é a biblioteca (sem nenhuma extensão de arquivo) que contém o código.

O Aimsun Next carregará o plug-in e procurará uma função C que criará uma instância de A2BehavioralModelCreator. A função C será chamada com o nome do plug-in conforme encontrado no arquivo XML, com o sufixo Factory. No exemplo anterior, o plug-in foi chamado MyModel, portanto a função será chamada MyModelFactory.

Ao especificar um Experimento em um Cenário Dinâmico, o comportamento externo pode ser ativado ou desativado na aba Behavior. Isso significa que um Cenário pode ser executado com dois Experimentos, um com e outro sem o comportamento modificado, e a diferença no comportamento da rede pode ser comparada.



Notas sobre Windows

No Windows, os símbolos devem ser exportados explicitamente. Para isso, o seguinte código: __declspec(dllexport) deve ser incluído. Isso se aplica tanto a classes quanto a funções C. É comum usar as seguintes instruções define para lidar com esse problema (o arquivo A2BehavioralModelUtil.h contém essas instruções):

#ifdef _WIN32
    #ifdef _A2BehavioralModelUtil_DLL
        #define A2BehavioralModelUtil_EXPORT __declspec(dllexport)
    #else
        #define A2BehavioralModelUtil_EXPORT __declspec(dllimport)
    #endif
#else
    #define A2BehavioralModelUtil_EXPORT
#endif

O Makefile (ou o Visual Settings) definirá _A2BehavioralModelUtil_DLL ao compilar o plug-in. E cada classe e função será decorada como:

class A2BehavioralModelUtil_EXPORT behavioralModelParticularCreator:
public A2BehavioralModelCreator 
{
    …
};
extern "C" A2BehavioralModelUtil_EXPORT A2BehavioralModelCreator *
MyModelFactory();