3.3 Mise en oeuvre de la simulation
Dans cette perspective, nous réalisons notre simulation
sous forme d'une applet java, une interface graphique qui permet de
contrôler les entrées nécessaires au lancement de la
simulation, de visualiser le comportement des agents dans un écran de
simulation, ainsi que d'afficher les résultats déduits.
MengerMelnikov
50
Centre
Rapétissement de polygone Trajectoires
30
20
10
40
0
10
20
30
40
50
50 40 30 20 10 0 10 20 30 40 50
Partie réelle
FIG. 3-4 - Rapetissement par Menger-Melnikov d'un polygone
formé par 16 agents
Schéma linéaire
20
Centre
Rapétissement de polygone Trajectoires
10
5
15
0
-5
-10
-15
-20
-20 -15 -10 -5 0 5 10 15 20
Partie réelle
Nos robots autonomes et homogènes sont
modélisés via des agents réactifs. L'espace dans lequel
ces agents errent est sous forme d'un plan à deux dimensions
considéré sans obstacles.
3.3.1 Cahier de charge du simulateur
la simulation va nous permettre de tester la validité
des solutions proposées dans le chapitre 3, de suivre et de
vérifier le comportement des agents dynamiquement et de mesurer certains
facteurs d'évaluation qui permettent de comparer entre les
différentes méthodes étudiées au chapitre
précédent.
L'utilisateur doit avoir la possibilité de :
- Choisir la stratégie ainsi que la méthode qu'il
désire tester,
- Introduire le nombre d'agents qui constitue le système,
ainsi que les différentes entrées nécessaires à
chaque méthode,
- Spécifier une précision qui représente
à quelle distance les agents doivent se réunir. Si cette
précision est nulle, les agents effectuent un rendez-vous au centre,
- Lancer la simulation, avec la possibilité
d'arrêter et de reprendre l'exécution ainsi que de l'annuler,
- Visualiser les résultats de chaque simulation
après son achèvement, stocker ces résultats qui
représentent le temps de convergence et la vitesse moyenne des agents,
ainsi que le nombre de senseurs nécessaires à la
méthode,
La possibilité d'afficher un rapport final regroupant les
résultats obtenus utilisant les différentes méthodes, et
de calculer les rapports de taux vus au chapitre précédent.
3.3.2 Conception du simulateur
Avant de réaliser la simulation, et
indépendamment du langage utilisé, nous allons d'abord passer par
une étape de conception de notre système multi-agents en
réalisant des modèles UML [14], pour décrire l'aspect
statique et dynamique de l'application.
Définition 3.2 La conception consiste à apporter
des solutions techniques aux descriptions définies lors de l'analyse, on
y définit les structures et les algorithmes sans tenir compte du langage
de programmation utilisé. Aujourd'hui, le standard industriel de
modélisation objet est UML (Unified Modeling Language). UML unifie
à la fois les notions et les concepts orientés objet, et aussi
les notations nécessaires aux différentes activités d'un
processus de développement et offre, par ce biais, le moyen
d'établir le suivi des décisions prises depuis l'expression des
besoins jusqu'au codage.
Dans ce qui suit, nous donnerons les diagrammes de conception de
la simulation.
Remarque 3.3 Dans notre projet, il s'agit de modéliser
un système multi-agents, or UML utilise une approche orientée
objets. Nous définissons un agent comme étant un objet
intelligent capable de prendre des décisions sans intervention externe,
ainsi les vocabulaires d'agent, de composant ou d'objet peuvent être
employés dans les divers contextes et domaines du coté de
l'utilisateur. Alors que du coté du développeur, il y a un lien
évident entre ces entités et il est même souhaitable
d'uniformiser les descriptions pour ne pas avoir à employer des
méthodes ou des formalismes différents.
Il n'existe pas moins de 12 diagrammes UML, partagés en
deux vues, une statique et l'autre dynamique. Nous utiliserons seulement deux,
chacun décrivant une vue pour modéliser notre système. Ces
diagrammes ont été conçus avec l'outil UMLEclipse de
l'éditeur Java Eclipse.
Modélisation structurelle
Pour donner une vue statique du système
c'est-à-dire représentant le système physiquement, nous
donnons le diagramme de classes (voir la figure 3-6), qui est le point central
dans le développement orienté objet, il représente la
structure du code orienté objet, et par la suite les modules qui
constituent l'application. Une classe est décrite par son nom, ses
attributs (propriétés) et ses méthodes (fonctions).
Mentionnons que notre interface hérite de la classe Applet et
implémente la classe Runnable (Thread). Ceci pour permettre à
l'utilisateur d'interrompre son exécution à n'importe quel
instant, modifier la vitesse de simulation, et ceci se traduit par un
pseudo-parallélisme dans l'exécution.
Légende du diagramme de classes
Définition 3.3 En Java:
Fonction (variable) publique : c'est une fonction (variable) qui
peut être appelée à partir d'autres classes du même
package.
Fonction (variable) privée : ne peut être que par la
classe mère, et les classes parentes.
Fonction synchronisée : désigne une fonction
partagée par plusieurs threads, rendre une fonction de type
"synchronized" fait qu'elle ne puisse être appelée que par un seul
thread à la fois.
FIG. 3-6 - Diagramme de classes
|
1
V= n
|
Xn
i=1
|
( di
temps) (3.3)
|
Description des classes
La classe Simulation Représente l'interface principale
de notre simulation, elle héritera dans la phase de réalisation
de la classe Java Applet de la bibliothèque Swing. Cette classe regroupe
les différents attributs et méthodes nécessaires à
la réalisation des simulations, dont :
Les attributs :
- Le nombre d'agents dans le système,
- Le nombre de couches dans le cas d'une poursuite cyclique
hiérarchique,
- Le nombre de liens dans le cas d'une poursuite cyclique
à liens,
- Le nombre de groupes dans le cas d'une poursuite cyclique
hiérarchique à deux couches, - Les positions des agents tout au
long de la simulation,
- La précision telle que nous l'avons définie
précédemment.
Les méthodes :
- Ci(zi_1, zi, zi+1) : la fonction
utilisée dans le rapetissement de courbe, décrivant
l'évolution des agents du système.
- RungeKuttaPC() : pour la résolution de l'équation
qui décrit le système dans le cas d'une poursuite cyclique.
- RungeKuttaRC() : La résolution de Runge kutta dans le
cas du rapetissement de courbe.
- FinSimulation() : Une fonction booléenne qui scrute la
fin de la simulation, autrement dit la réunion au centre.
- CalculNcouches() : Une fonction permettant le calcul des
nombres de couches (L) admissibles en fonction du nombre d'agents saisi. La
simulation permet d'effectuer les poursuites cycliques hiérarchiques
:
- à 2 couches, avec possibilité de contrôler
le nombre d'agents dans chaque groupe.
- Le cas optimal du schéma général, tel que
nous l'avons vu auparavant, c'est à dire lorsque
pNL
2 N. Dans cette fonction, il s'agit de retrouver tous les L
valides tels que cette condition L
soit vérifiée.
- CalculPositions() : Calcule les positions des agents dans le
temps jusqu'à l'arrivée au centre et qui fait appel aux fonctions
RungeKutta().
- CentreAgents() : Retourne les coordonnées du centre des
agents.
- VitesseMoyenne() : Retourne la vitesse moyenne des agents, un
facteur d'évaluation entre les différentes méthodes.
di : la distance parcouru par l'agent i.
temps : Le temps de convergence. C'est à dire, le temps
nécessaire à l'accomplissement du rendez- vous.
- SauvegarderResult() : Une fonction qui permet de stocker les
résultats obtenus (temps de convergence, vitesse moyenne, nombre de
senseurs) des différentes méthodes, pour un nombre d'agents
donné, afin de pouvoir les comparer. Les résultats ne sont
sauvegardés que si cette simulation n'a jamais été
lancée.
- CalculTaux() : Calcule l'augmentation dans les taux de
convergence entre les différentes méthodes de la poursuite
cyclique, ceux que nous avions approximé au chapitre 2. Le taux est
calculé dans les cas que nous avons déjà vus.
La classe EcranSimulation Regroupe les propriétés
de l'écran d'affichage des simulations, ainsi que des fonctions
graphiques permettant son affichage, sa mise à jour ...
Les attributs :
- hight et width : décrivent les dimensions de
l'écran.
- bordure : l'épaisseur de la bordure.
Les méthodes :
- paint() : la méthodes qui permet d'initialiser et
d'afficher l'écran de simulation.
- Update() : met à jour l'écran, en affichant les
nouvelles positions des agents ainsi que le centre. Elle est appelée par
la classe Simulation.
- putPoint() : dessine un point (représentant un agent) su
l'écran.
- Move() : la fonction qui gère le curseur, pour
récupérer sa position d'où celle de l'agent à
placer.
La classe Agent Comme chaque agent est
représenté par sa position sous forme d'un nombre complexe, cette
classe regroupera les propriétés et les fonctions qui
gèrent les nombres complexes, telles que :
Les attributs :
x, y : la partie réelle et imaginaire du nombre complexe,
représente aussi les coordonnées d'un agent selon l'axe des
abscisses et des ordonnées.
Les méthodes :
- real() et imag() : retournent la partie réelle et
imaginaire d'un nombre complexe. - mod() : retourne le module d'un nombre
complexe, représente la vitesse d'un agent. - conj (): retourne le
conjugué complexe d'un nombre complexe.
- plus(), minus(), times(), div (), scal() : les
opérations effectuées sur les nombres complexes telles que :
l'addition, la soustraction, le produit, la division ainsi que la
multiplication par un réel.
La classe Matrice Une classe regroupant un ensemble de
fonctions pouvant être effectuées sur des matrices carrées
telles que : l'addition, la soustraction, le produit vectoriel, ... mais aussi
des fonctions complexes telles que la construction d'une matrice circulante de
dimension donnée.
Les attributs : Sont la matrice elle même (mat) et
sa dimension (n).
Les méthodes :
- Identite() : Retourne la matrice identité de dimension
n.
- Sub(), Plus (), ProduitVectorielCarre() : retournent les
résultats de l'addition, la différence, et le produit vectoriel
de 2 matrices carrées.
- ProduitMatScal() : retourne une matrice qui résulte
produit d'un nombre réel par la matrice mat.
- SommeV() : somme de deux vecteurs.
- Modulo(i, pas, n) : retourne le résultats de (i + pas)
mod n.
- Circulante(m, n1, nm) : une fonction
récursive qui calcule la matrice circulante décrite dans la
formule 2.15. avec m est le nombre de couches, n1 le nombre d'agents de la
première couche, et nm le cardinal de chaque couche.
Circulante(n, n1) : un cas particulier de la matrice circulante
qui est celle de la poursuite cyclique hiérarchique à deux
couches, deux attributs sont nécessaires dont le nombre d'agents total
et le nombre d'agents de chaque groupe, calculé à partir du
nombre de groupes.$ Lliens(L, n) : retourne la matrice circulante de la
poursuite cyclique à L liens, telle qu'elle est décrite dans la
formule 2.17.
La classe Taux Cette classe représente les rapports de
taux entre les différentes méthodes de la poursuite cyclique.
Les attributs : meth1 et meth2 pour décrire les
deux méthodes comparées, et val la valeur du rapport
approximé précédemment.
Les méthodes : Taux(meth1, meth2) : le constructeur
de la classe.
La classe Rapport Cette classe représente une
fenêtre (Frame) indépendante qui affiche le rapport regroupant les
différents résultats obtenus lors des simulations lancées
pour un groupe d'agents donné.
Les attributs : seulement un champs de texte qui affiche
le rapport.
Les méthodes :
- Initialize() : réinitialisation du champs de texte, par
exemple après changement du groupe d'agents.
- Ecrire() : Ecrit un rapport dans le champs de texte qui
contient : le temps de convergence, le vitesse moyenne et le nombre de senseurs
de toutes les simulations, ainsi que les rapports calculés entre les
différentes méthodes de la poursuite cyclique.
Modélisation comportementale
Nous avons choisi le diagramme de séquences (voir
figure 3-7), pour modéliser la vue dynamique de la simulation, montrer
son fonctionnement et l'interaction entre l'utilisateur et l'interface de
simulation.
| 
