La trajectoire d’un Agent Trajectoire est le résultat de l’auto-organisation d’un ensemble d’Agents Parties qui planifient localement leur trajectoire. Chaque Agent Partie correspond alors à une partie de trajectoire, lié à deux Agents Parties, un suivant et un précédent (sauf les agents de début et fin de trajectoire, qui sont chacun liés à un Agent Extrémité). L’Agent Partie assume un rôle service selon le pattern AMAS4Opt pour son Agent Trajectoire. Initia- lement, l’Agent Partie correspond exactement à une partie de trajectoire originale provenant de la base de données de trajectoires apprise par EVAA. Au cours de l’adaptation de l’Agent Partie, cette partie de trajectoire peut être modifiée afin de générer une meilleure trajectoire pour l’Agent Trajectoire, respectant toujours les contraintes de l’entité mobile. Sa structure est décrite par la figure 7.6.
La figure 7.6 décrit la structure de l’Agent Partie que nous utilisons pour décrire le reste de cet agent.
Le but de chaque Agent Partie est de définir localement une partie de trajectoire reliant les Agents Parties liés à lui et réaliste du point de vue physique et du point de vue du com- portement. La criticité de cet agent, Critpart, est décomposée en trois sous-objectifs :
1. La capacité de définir une partie de trajectoire complète, notée Critpart,comp. Cette capa-
cité s’exprime par la jonction avec les Agents Parties précédent et suivant.
2. La définition d’une partie de trajectoire réaliste du point de vue du comportement dans le trafic, notée Critpart,tra f f.
3. La faisabilité de la partie de trajectoire, notée Critpart, f eas.
7.7. Présentation de l’Agent Partie
Algorithme 7.5 :Comportement d’un Agent Trajectoire dans l’état Recherche Traj 1: si Critsit6=
−→
0 ou Crittraj6=
−→
0 alors // Si la criticité de son Agent Situation et de sa trajectoire n’est pas nulle
2: pour toutCaracteristique c∈caracteristiquesSituation faire // L’Agent Trajectoire demande la criticité des caractéristiques (Critsit) qui lui sont déléguées aux entités
passives Caractéristiques 3: getCriticiteCar(c) 4: fin pour
5: pour toutAgentPartie a∈agentsPartie faire // L’Agent Trajectoire demande à ses Agents Parties de modifier leur trajectoire pour améliorer la criticité de sa trajectoire Crittraj
6: envoyerDemandeChangementPartie(a) 7: fin pour
8: sinon
9: etatCourant←Satisfait // L’Agent Trajectoire passe dans l’état Satisfait car sa criticité et celle de son Agent Situation sont nulles
10: fin si
11: pour toutAgentTrajectoire a∈agentsTrajectoire faire
12: envoyerCriticiteTraj(a) // L’Agent Trajectoire envoie sa criticité aux autres Agents Trajectoires de son Agent Situation
13: envoyerTrajectoire(a) // L’Agent Trajectoire envoie sa trajectoire aux autres Agents Trajectoires de son Agent Situation
14: fin pour
15: si agentExtremite[0] 6=null∧agentExtremite[1] 6=null alors // Si sa trajectoire est suffisamment complète, l’Agent Trajectoire cherche des Agents Extrémités d’où partira et arrivera l’Agent EM qui suivra sa trajectoire, puis leur demande de créer cette entité 16: si agentEM=null alors
17: envoyerDemandeCreationAgentEM(agentExtremite[0]) // L’Agent Trajectoire demande à l’Agent Extrémité de départ de créer une Agent EM
18: sinon
19: pour toutAgentExtremite ae∈agentsExtremite faire // L’Agent Trajectoire envoie sa trajectoire à ses deux Agents Extrémités
20: envoyerTrajectoire(ae)
21: fin pour
22: fin si
23: sinon
24: choisirAgentExtremite(trajectoire) // S’il le peut, l’Agent Trajectoire décide de l’Agent Extrémité d’où part et où arrive sa trajectoire
25: fin si
26: envoyerCriticiteTraj(agentSituation) // L’Agent Trajectoire envoie sa criticité à son Agent Situation
27: envoyerTrajectoire(agentSituation) // L’Agent Trajectoire envoie sa trajectoire à son Agent Situation
28: envoyerTrajectoire(agentEM)// L’Agent Trajectoire envoie sa trajectoire à son Agent EM
Figure 7.6 – Structure de l’Agent Partie
pouvant être ajoutés en fonction des applications, mais ces distances sont les bases néces- saire à la définition de ces criticités (l’altitude n’est pas toujours nécessaire, mais existe aussi dans le trafic routier, puisque celui-ci joue aussi avec l’altitude, par exemple les échangeurs, les ponts ou encore les parking à plusieurs étages) :
1. la distance géographique, 2. la distance temporelle, 3. la distance en altitude, 4. la distance de vitesse.
Dans AGATS, les parties de trajectoires sont des segments caractérisés, entre autres, par : — une position géographique de départ et d’arrivée en longitude et latitude,
— une altitude de départ et d’arrivée en pied,
— un intervalle de temps durant lequel l’avion a utilisé ce segment, — un modèle d’avion,
— un indicatif de vol, qui contient notamment la compagnie aérienne.
Ainsi, les criticités Critpart,compet Critpart,tra f f sont composées d’au moins 4 sous-criticités
que nous notons Critpart,comp,let Critpart,tra f ,l, avec l ∈J1, 4K, selon l’énumération précédente. Ces différentes criticités se calculent en utilisant la fonction générique de criticités décrite par l’équation 7.2, où dmax,l est la valeur maximale de distance prise en compte pour l’axe l,
7.7. Présentation de l’Agent Partie
et dl est une fonction de distance pour l’axe l, appliquée à 2 variables v1, la valeur a obtenir,
et v2la valeur actuelle. C(x) = 1000 dmax,ldl(v1, v2) if dl(v1, v2) <dmax,l 1000 if dl(v1, v2) ≥dmax,l (7.2)
Concrètement, les valeurs considérées pour chaque axe sont :
1. d1 est la distance en kilomètres entre 2 points géographiques (v1 et v2) en longitude
et latitude, et dmax,1 = 60km, une distance utilisée pour déterminer le voisinage dans
EVAA [Rantrua, 2017].
2. d2 est la distance en secondes entre 2 dates (jour, heure, secondes) modulo le jour, et
dmax,2=3600s, le temps d’une simulation d’apprentissage pour un contrôleur,
3. d3 est la distance entre 2 altitudes en m, et dmax,3 = 3048m = 10000 f t, la moitié de la
hauteur de l’espace aérien inférieur, qui est suffisamment significative pour se traduire par un changement de typologie de trafic (voir section 1.2.1, en particulier figure 1.3), 4. d4 est la distance entre 2 vitesses en kilomètres par heure, et dmax,4 est 450km.h−1, la
moitié de la moyenne de vitesse de croisière des avions commerciaux.
Pour chaque Agent Partie, la criticité de complétude de sa partie selon chaque axe,
Critpart,comp,l, est composée de 2 criticités, dont le calcul se fait selon la fonction 7.2 :
— la distance dl selon l’axe l, entre le point d’origine de la partie de trajectoire de l’Agent
Partie (v1), et la destination de l’Agent Partie précédant l’Agent Partie (v2). Cette criticité
est noté Critpart,comp,l,prev,
— la distance dl selon l’axe l, entre le point de destination de la partie de trajectoire de
l’Agent Partie (v1), et l’origine de l’Agent Partie suivant l’Agent Partie (v2). Cette criticité
est noté Critpart,comp,l, f oll.
Il est informé de l’état de la partie de ses deux Agents Parties voisins (AgentPartie[] partie- TrajectoireVoisin) par des envois de messages (void envoyerEtatPartie(@AgentPartie))
La figure 7.7 illustre ces criticités pour l’Agent Partie AP6 en représentant les distances
utilisées pour Critpart,comp,l, f oll (d1, f oll), et pour Critpart,comp,l,prev (d1,prev) pour l’axe des dis-
tances géographiques.
La criticité de l’Agent Trajectoire par rapport à la complétude de sa trajectoire (Crittraj,comp)
est donc formée par la criticité de chaque Agent Partie le composant (figure 7.8).
Le calcul de Critpart,tra f f se fait par comparaison de la partie de trajectoire actuelle de l’Agent Partie (PartieTrajectoireBDT partieTrajectoireActuelle) avec la partie de trajectoire origi- nale (PartieTrajectoireBDT partieTrajectoireOriginale), c’est-à-dire celle qui vient de la base de données de trajectoires : plus la partie de trajectoire actuelle est proche de la partie de trajec- toire originale, plus la criticité est basse et plus la partie de trajectoire est réaliste du point de vue du comportement. Ainsi, la partie de trajectoire contient le réalisme du comportement. Pour évaluer cette différence, nous utilisons les 4 même axes et les 4 même distances que précédemment, et nous avons donc une criticité Critpart,tra f f ,lassociée à chaque axe.
Chaque Critpart,tra f f ,l est calculée en utilisant une fonction dérivée de la fonction géné-
rique 7.2. dl (l ∈ J1, 4K), et appliquée à 2 couples puis sommée pour calculer la criticité,
Figure 7.7 – Illustration des distances utilisées pour calculer la criticité de complétude selon l’axe géographique, Critpart,comp,1.
Crittraj,comp Critpart,comp Critpart,comp,1 Critpart,comp,1,prev
Critpart,comp,1, f oll
| {z }
Les 2 composantes de Critpart,comp,1
Critpart,comp,2
Critpart,comp,3
Critpart,comp,4
| {z }
Expression de Critpart,compselon les 4 axes
.
. .
| {z }
Décomposition de Crittraj,compselon les Agents Parties de l’Agent Trajectoire
Figure 7.8 – Une vue hiérarchique de la criticité de l’Agent Trajectoire par rapport à la com- plétude de sa trajectoire, Crittraj,comp
selon la fonction 7.3. Le premier couple,(v1, v2), correspond au départ de la partie de tra-
jectoire actuelle de l’Agent Partie (v1) et au départ de la partie de trajectoire originale (v2). Le
deuxième couple correspond à la destination de la partie de trajectoire de l’Agent Partie (v3)
et à la destination de la partie de trajectoire originale (v4).
C(x) = 1000 dmax,l(dl(v1, v2) +dl(v3, v4)) if(dl(v1, v2) +dl(v3, v4)) <dmax,l 1000 if(dl(v1, v2) +dl(v3, v4)) ≥dmax,l (7.3)
La figure 7.9 illustre la valeur des deux distances utilisées pour le calcul de Critpart,tra f f ,1
pour l’axe des distances géographiques.
7.7. Présentation de l’Agent Partie
Figure 7.9 – Illustration des distances utilisées pour calculer la criticité de l’Agent Partie par rapport au réalisme de sa partie de trajectoire du point de vue du comportement, selon l’axe géographique, noté Critpart,tra f f ,1.
Crittraj,tra f f Critpart,tra f f Critpart,tra f f ,1 Critpart,tra f f ,2 Critpart,tra f f ,3 Critpart,tra f f ,4 | {z }
Expression de Critpart,tra f f selon les 4 axes
.
. .
| {z }
Décomposition de Crittraj,tra f f selon les Agents Parties de l’Agent Trajectoire
Figure 7.10 – Une vue hiérarchique de la criticité de l’Agent Trajectoire par rapport au réa- lisme comportemental de sa trajectoire, Crittraj,tra f f
vue du comportement (Crittraj,tra f f) est donc formée par la criticité de chaque Agent Partie le
composant (figure 7.10).
La criticité Critpart, f eas est quant à elle calculée par l’Agent EM suivant la trajectoire de son Agent Trajectoire.
Afin d’atteindre ces différents buts, et de faire diminuer sa criticité (CritpartcriticitePartie)
l’Agent Partie est capable d’effectuer 4 actions différentes :
— Action 1 : Modifier les caractéristiques (ActionPartie modifierPartie()) de sa partie de tra- jectoire (PartieTrajectoireBDT partieTrajectoireActuelle), par exemple augmenter la vitesse de l’entité mobile qui suit sa partie de trajectoire.
— Action 2 : Substituer sa partie de trajectoire par une autre partie de trajectoire venant de la base de données de trajectoire (ActionPartie substituerPartie(PartieTrajectoireBDT[])). — Action 3 : Ajouter un nouvel Agent Partie (ActionPartie ajouterPar-
tie(PartieTrajectoireBDT[])), cette action peut être faite pour compléter la trajectoire, ou
pour l’étendre. Il peut ajouter un Agent Partie avec une partie de trajectoire spécifique avant ou après sa propre partie de trajectoire, en utilisant une partie de trajectoire venant de la base de données de trajectoires.
— Action 4 : Se supprimer (ActionPartie supprimerPartie()), cette action est exécutée lorsque l’Agent Partie considère qu’il est plus coopératif de laisser les Agents Parties précédant et suivant se rejoindre plutôt que d’effectuer l’une des trois actions précédentes.
Pour l’action 1, la modification d’une partie de trajectoire (ActionPartie modifierPartie()) se fait selon un seul des 4 axes utilisés suivants :
1. Une modification selon l’axe géographique se fait par translation de la partie de trajec- toire, ou sa rotation, préservant ainsi la longueur et la forme de la partie de trajectoire, et maintient donc le réalisme physique. Le pseudo algorithme 7.6 décrit la translation d’un segment d’EVAA (illustrée par la figure 7.11), et le pseudo algorithme 7.7 décrit la rotation (illustré par la figure 7.12), puisque ces opérations sont moins triviales sur une sphère. Le point utilisé comme centre de la rotation est le milieu de la partie de trajectoire de l’Agent Partie
2. Une modification selon l’axe temporel se fait en modifiant le temps pour toute la partie de trajectoire.
3. Une modification selon l’axe de l’altitude se fait en modifiant la hauteur pour toute la partie de trajectoire.
4. Une modification selon l’axe de la vitesse se fait en augmentant ou en diminuant la vitesse sur toute la partie de trajectoire.
Algorithme 7.6 :Translation d’un segment d’EVAA
1: Choisir l’un des deux points extrêmes du segment, noté−→p1, disons le départ
(respectivement l’arrivée) du segment, et translater ce point dans la direction voulue et la distance voulue. Nous notons le point translaté−→p3.
2: Translater−→p3 selon l’orientation (respectivement l’orientation contraire) et la longueur
du segment. Nous notons le point translaté−→p4
Algorithme 7.7 :Rotation d’un segment d’EVAA par un point quelconque
1: Choisir le point de translation, généralement celui-ci appartient au segment, noté−→prot.
2: Calculer la distance d1entre−→protet le départ du segment−→p1
3: Calculer l’orientation α1de−−−→protp1
4: Calculer l’orientation α01 =α1+angleRotation de−−−→protp1, avec−→p3 le futur point du
segment translaté.
5: Translater−→protselon l’orientation α01et la distance d1. Ce point translaté correspond à
− →
p3.
6: Translater−→p3 selon l’orientation orientationSegment+angleRotation et la distance du
segment. Ce point translaté correspond à−→p4.
L’Agent Partie modifie selon l’axe dont la criticité est maximale (parmi tous les axes) dans le but de diminuer celle-ci (algorithme 7.8).
7.7. Présentation de l’Agent Partie
Figure 7.11 – Illustration de translation d’une partie de trajectoire (les étapes correspondent à celles de l’algorithme 7.6)
Figure 7.12 – Illustration de la rotation d’une partie de trajectoire (les étapes correspondent à celles de l’algorithme 7.7)
Pour l’action 2, la substitution d’une partie de trajectoire par une autre se fait en re- quérant des parties de trajectoires proches dans la base de données de trajectoire (Partie- TrajectoireBDT[] getDonneesBDT()), en évaluant chacune de ces parties de trajectoire (Critpart
calculerCriticiteAnticipePartie(PartieTrajectoireBDT)), et en choisissant celle qui fait diminuer le plus la criticité maximale actuelle (algorithme 7.9).
L’évaluation de l’action 3 d’ajout d’une nouvelle partie de trajectoire entre un Agent Par- tie et l’un de ses deux voisins, se fait par l’évaluation de la somme des criticités de ces 2 Agents Parties et sa comparaison avec la somme des deux criticités anticipées des Agents Par- ties avec celle du nouveau Agent Partie (algorithme 7.10). L’évaluation de l’ajout se fait en amont de l’Agent Partie dans la trajectoire (CritpartcalculerCriticiteAnticipePartieAjouterAvant
(PartieTrajectoireBDT)), et en aval (Critpart calculerCriticiteAnticipePartieAjouterApres (Partie-
TrajectoireBDT)), afin d’évaluer les différentes possibilités. La figure 7.13 illustre l’ajout en
Algorithme 7.8 :Modification d’une partie de trajectoire d’un Agent Partie 1: PartieTrajectoire pt
2: pt←modifierPartie(partieTrajectoireActuelle) // L’Agent Partie calcule la modification de sa partie de trajectoire actuelle
3: Renvoyer new ActionPartie(Modifier(pt), calculeCriticiteAnticipePartie(pt)) // L’Agent Partie calcule sa criticité anticipée s’il effectue cette action
Algorithme 7.9 :Substitution d’une partie de trajectoire d’un Agent Partie 1: PartieTrajectoireBDT[] ps
2: Critpart[] cs
3: ps←getDonnesBDT() // L’Agent Partie cherche dans la base de données de trajectoires des parties de trajectoires qui pourraient convenir à la substitution
4: pourk←1 à ps.taille() faire
5: cs[k]←calculerCriticiteAnticipePartie(ps[k]) // L’Agent Partie calcule la criticité anticipée de la substitution de la partie de trajectoire partieTrajectoireOriginale par la partie de trajectoire ps[k]
6: fin pour
7: Soit lmin/ cs[lmin] = min
l cs[l]// L’ Agent Partie détermine la partie de trajectoire qui fait
le plus diminuer la criticité
8: Renvoyer new ActionPartie(Substitution(ps[lmin]), cs[lmin])
amont (AP50) et en aval (AP70) d’un Agent Partie pour l’Agent Partie AP6(à des fins de clarté,
nous ajoutons une partie de trajectoire différente).
Figure 7.13 – Illustration de l’ajout d’une partie de trajectoire
7.7. Présentation de l’Agent Partie
Algorithme 7.10 :Ajout d’une partie de trajectoire d’un Agent Partie 1: PartieTrajectoire[] ps
2: Critpart[] csApres
3: Critpart[] csAvant
4: ps←getDonnesBDT() // L’Agent Partie cherche dans la base de données de trajectoires des parties de trajectoire qui pourraient convenir à l’ajout
5: pourk←1 à ps.taille() faire // Pour chaque partie de de trajectoire ps[k], l’Agent Partie calcule la criticité anticipée de l’ajout de ps[s] avant ou après lui
6: csAvant[k]←calculerCriticiteAnticipePartieAjoutAvant(ps[k]) 7: csApres[k]←calculerCriticiteAnticipePartieAjoutApres(ps[k]) 8: fin pour
9: Soit lmin,avant/ csAvant[lmin] = min
l csAvant[l]// L’Agent Partie détermine la partie de
trajectoire qui diminue le plus la criticité si elle est ajoutée avant lui 10: Soit lmin,apres / csApres[lmin] = min
l csApres[l]// L’Agent Partie détermine la partie de
trajectoire qui diminue le plus la criticité si elle est ajoutée après lui
11: si csAvant[lmin,avant] >csApres[lmin,apres]alors// L’Agent Partie détermine lequel des
deux ajouts (avant ou après) diminue le plus la criticité, et renvoi l’action appropriée 12: Renvoyer new ActionPartie(Ajouter(Apres,ps[lmin,apres]), csApres[lmin,apres])
13: sinon
14: Renvoyer new ActionPartie(Ajouter(Avant,ps[lmin,avant]), csAvant[lmin,avant])
15: 16: fin si
ticité maximale actuelle totale de l’Agent Partie avec celle de ses 2 voisins, et l’évaluation de la criticité totale de ses 2 voisins sans lui (CritpartcalculerCriticiteAnticipePartieSupprimer()).
Tant que ses différentes sous-criticités ne sont pas nulles, l’Agent Partie étudie les dif- férentes actions possibles (modifier, substituer, ajouter, se supprimer), et choisit l’action qui diminue le plus sa criticité (algorithme 7.11), applique l’action associée (modifier sa partie de trajectoire, substituer sa partie de trajectoire, ajouter une partie de trajectoire, se modifier), et indique à son Agent Trajectoire (AgentTrajectoire agentTrajectoire) et à ses deux Agents Parties voisins (AgentPartie agentPartieVoisin) son nouvel état (void envoyerEtatPartie(@AgentPartie), void envoyerEtatPartie(@AgentTrajectoire)). Si l’action est un ajout, l’Agent Partie crée un nou- vel agent (AgentPartie creerAgentPartie(PartieTrajectoireBDT)), et ce nouveau agent indiquera son existence à l’Agent Trajectoire (void envoyerNouvellePartie(@AgentTrajectoire)) et à ses Agents Parties voisins (void envoyerNouvellePartieVoisine(@AgentPartie)). Si l’action est une suppression, l’Agents Parties indique à son Agent Trajectoire et à ses deux Agents Parties voi- sins sa suppression (void envoyerSupressionPartie(@AgentTrajectoire) et void envoyerSupression- PartieVoisine(@AgentPartie)).
Algorithme 7.11 :Comportement de l’agent Agent Partie 1: PartieTrajectoireBDT[] ps
2: ActionPartie[] acs // Table contenant l’évaluation de l’ensemble des actions de l’Agent Partie
3: ActionPartie ac // Variable temporaire qui recevra l’action choisie 4: si Critpart 6=
−→
O alors // Si la criticité de l’Agent Partie est non nulle, il essaye de diminuer celle-ci
5: ps←getDonneesBDT()
6: acs[1]←modifierPartie() // L’Agent Partie calcule la meilleure modification de sa partie de trajectoire et sa criticité anticipée associée
7: acs[2]←substituerPartie(ps) // L’Agent Partie calcule la meilleure substitution de sa partie de trajectoire et sa criticité anticipée associée
8: acs[3]←supprimerPartie() // L’Agent Partie calcule la criticité anticipée de son voisinage s’il se supprime
9: acs[4]←ajouterPartie(ps) // L’Agent Partie calcule le meilleur ajout et la criticité anticipée de son voisinage associée
10: ac←choisirChangementPartie(acs) // L’Agent Partie détermine l’action qui fait le plus diminuer sa criticité anticipée
11: ac.appliquer() // L’Agent Partie applique l’action
12: etatPartie(agentTrajectoire) // L’Agent Partie envoi son nouvel état à son Agent Trajectoire
13: pour toutAgentPartie a∈agentsPartieVoisin faire
14: envoyerEtatPartie(a) // L’Agent Partie envoi son nouvel état à ses Agents Parties voisins
15: fin pour
16: fin si