TP1 : Simulation de files d`attente (1ère partie)

TP1 : Simulation de files d’attente (1ère partie)
Notions utilisées :
 Programmation orientée objet en C++ :
- Construction d’une classe
- Objets membres
- Création et destruction d’objets
- Appels de méthodes
 Structure de données : Files d’attente
Le but de cet exercice est de simuler l’arrivée et le traitement des patients arrivant au service des
urgences d’un hôpital afin d’étudier les délais d’attente en fonction de l’affluence et du nombre
de personnels hospitaliers.
1. Construire la classe Patient :
Attributs (privés) :
- Un identifiant. Pour simplifier, un patient sera identifié par son ordre d’arrivée (int)
- L’heure d’arrivée (double)
- Le niveau de priorité attribué après la consultation initiale par un infirmier (int)
Méthodes (publiques) :
- Constructeur avec en paramètres l’identifiant et l’heure d’arrivée
- Accesseurs en lecture ou en écriture si nécessaires
- Méthode pour afficher les données d’un patient
Tester votre classe : faire un programme qui crée un patient, lui attribue un niveau de
priorité, puis affiche les données du patient.
2. Files d’attente de patients.
Les files d’attente seront implémentées par chaînage dynamique : les éléments sont enfilés en
queue de liste et défilés en tête.
 classe Cell pour les maillons :
Cell.h
#include <stdlib.h>
#include “ Patient.h “
class Cell{
private :
Patient* data ;
Cell* next ;
public :Cell (Patient* p) ; // constructeur
~Cell() ; //destructeur
Patient* getData() ;
Cell* getNext() ;
void setNext(Cell* next) ;
} ;
Coder les méthodes de la classe Cell dans un fichier source Cell.cpp :

 classe FilePatients :
FilePatients.h
#include "Cell.h"
class FilePatients{
private :
int taille ;
Cell* tete ;
Cell*queue ;
public :FilePatients() ;
bool isVide() ;
int getTaille() ;
void enfiler (Patient*p) ;
Patient* defiler() ;
} ;
FilePatients.cpp
#include "FilePatients.h"
…
Patient* FilePatients::defiler (){
if (isVide()) return NULL;
else{
Cell*c=tete;
Patient*p=c->getData();
if(tete==queue)
tete=queue=NULL;
else tete=tete->getNext() ;
delete(c);
taille--;
return p;
}
}
…
- La méthode défiler() vous est donnée ci-dessus. Coder les autres méthodes.
- Tester vos classes : faire un programme qui enfile 10 patients puis les défile.
Ajouter une méthode afficher() dans la classe FilePatients pour visualiser l’état des
files ( file d’attente : o-|-< o-|-< o-|-< ).

3. Simulation 1 :
On suppose dans un premier temps que les patients sont examinés selon l’ordre de leur arrivée (file
d’attente) et qu’un seul médecin assure les consultations.
Normallement, tant que le nombre moyen d’arrivée de patients par heure (taux d’arrivée) est
inférieur au nombre moyen de consultations pouvant être effectuées  (taux de service  =1/(durée
moyenne d’une consultation)), la demande peut être satisfaite ; mais à cause des irrégularités dans les
heures d’arrivée des patients et dans les durées de consultation, des files d’attente parfois longues peuvent
se former.
Le nombre de patients arrivant aux urgences peut être simulé suivant une loi de Poisson de paramètre
: p(np=k) =
k e-
k! . Les intervalles de temps T entre arrivées suivent alors une loi exponentielle de
paramètre (T) = e-
T . La durée des consultations est elle aussi supposée suivre une loi
exponentielle de paramètre 
Pour la simulation, une heure correspondra à 10 secondes de temps d’éxecution.
Construire une classe Simulation1 permettant de simuler la file d’attente des patients et
d’estimer le temps moyen d’attente :
- Attributs :
Paramètres de la simulation : durée simulée (en heure), nombre moyen d’arrivée ( durée moyenne
d’une consultation (1/)
Résultats : Temps moyen d’attente, taille moyenne de la file
Objet membre : File d’attente de patients
- Méthodes :
Constructeur : SimuFileAttente(double duree,double taux,double dc)
Méthode qui retourne le temps écoulé (en heure) : double getTime()
Méthode qui génère aléatoirement l’heure d’arrivée du prochain patient : double nextArrivee(double t)
Méthode qui tire aléatoirement une durée de consultation : double dConsult()
Lancement de la simulation : void lancer()
Les méthodes getTime(), nextArrivee() et dConsult() vous sont données :
Simulation1.cpp
#include "SimuFileAttente.h"
#include <time.h>
#include <math.h>
…
double SimuFileAttente::getTime(){
return (clock()/(CLOCKS_PER_SEC*1.0))/10.0;
}
double SimuFileAttente::nextArrivee(double t){
double alea =(rand()%100)/100.0;
double next = t+((-1.0/tauxArrivee)*log(1.0-alea));
return next;
}
double SimuFileAttente::dConsult(){
double alea =(rand()%100)/100.0;
double d = -m*log(1.0-alea);
return d;
}
…

Coder la méthode de simulation lancer() dont l’algorithme est le suivant :
Il y a un medecin disponible (ndispo=1)
Estimer l’heure d’arrivée du premier patient
Faire Si un patient arrive (si l’heure d’arrivée du prochain patient est dépassée)
Créer patient
Enfiler patient
Estimer l’heure d’arrivée du prochain patient
FinSi
Si le médecin est disponible (ndispo=1) et qu’un patient attend (file non vide)
Défiler patient
Calculer le temps d’attente du patient (temps-heure d’arrivée du patient) ) (pour
calculer le temps moyen d’attente)
Enregistrer l’heure de début de consultation
Estimer la durée de la consultation
Il n’y a plus de médecin disponible (ndispo=0)
FinSi
Si le medecin termine une consultation (si le medecin est en consultation et que la durée de la
consultation s’est écoulée)
Le médecin redevient disponible
FinSi
Enregistrer régulièrement la taille de la file (par exemple toutes les minutes) (pour calculer la
taille moyenne de la file)
Tant que (temps<durée de la simulation)
Calculer la moyenne des temps d’attente
Calculer la taille moyenne de la file
N’oubliez pas d’initialiser le générateur de nombres aléatoires : srand(time(NULL)) ;
Afficher la file d’attente à chaque arrivée ou départ d’un patient.
En fin de simulation, afficher le temps moyen d’attente et la taille moyenne de la file.
Faire un programme qui lance une simulation de 12 heures avec comme paramètres un
taux d’arrivée de 9 patients par heure et une durée moyenne de consultation de 0.1
heure (6 minutes).
Relancer plusieurs fois la simulation pour observer les variations dues aux irrégularités
des temps d’arrivée et des durées de consultation.
Faites varier les paramètres. Qu’observez-vous ?