Phénomènes D Attente Et Application À La Gestion Des Feux de Circulation

1
TER
MASTER SITN
Phénomènes d’attente et application à la

gestion des feux de circulation
Réalisé par
AUGER Vincent
THIRARD Colin
2013
Sous la Direction de : PERRUT Anne

TABLE DES MATIÈRES 2
Table des matières

1 Introduction 3
2 Etude théorique des systèmes d’attente 4

2.1 Introduction : classification des systèmes d’attente . . . . . . . . . . . . . . . . . 4
2.2 Le système d’attente M/M/1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.2.1 Analyse mathématique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.2.2 Regime transitoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.2.3 Regime stationnaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.3 Caractéristiques d’exploitation du système M/M/1 . . . . . . . . . . . . . . . . . 7
2.3.1 Définitions, formules de Little . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.3.2 Calcul des caractéristiques . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.4 Une simulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.4.1 Q > 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.4.2 Q = 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.4.3 Q < 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
3 La situation routière de Daniel Flipo 12

3.1 Introduction et description du modèle . . . . . . . . . . . . . . . . . . . . . . . . 12
3.2 Cycle des feux, engorgement, contraintes . . . . . . . . . . . . . . . . . . . . . . . 12
3.2.1 Cycle des feux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
3.2.2 Engorgement, contraintes . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
3.3 La question de l’estimation des paramètres . . . . . . . . . . . . . . . . . . . . . 13
3.4 Simulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
3.5 Amélioration du modèle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3.6 Le modèle à deux voies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
4 Annexe : codes scilab 19

4.1 Loader.sce . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
4.2 MM1.sci . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
4.3 Longueur.sci . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
4.4 Trajplot.sci . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
4.5 Trajgraph.sci . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
4.6 Trajanim.sci . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
4.7 Traj.sci . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
4.8 Traj_ journee.sci . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
4.9 Trajgraph_ tps.sci . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
4.10 Trajanim2.sci . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
1 INTRODUCTION 3
1 Introduction
Au cours de ce projet nous allons nous interesser à une catégorie de systèmes que l’on peut
modéliser mathématiquement : les systèmes d’attente.
On peut schématiser un système (ou phénomène) d’attente comme suit : les clients arrivent
dans le système et sont accueillis dans l’espace d’attente. Après avoir passé l’éventuelle file d’at-
tente, ils accèdent à l’espace de service, où se trouvent un ou plusieurs postes de service que le
client souhaite consulter avant de sortir du système.
On trouve de nombreux exemples de ces phénomènes d’attente dans notre quotidien :

– arrivée de voitures vers une station-service ;
– fonctionnement d’un central téléphonique ;
– vente de billets auprès d’un guichet ;
– atterissage des avions sur un aéroport...
On réalisera une étude théorique d’un certain type de systèmes d’attente adaptés à la situa-
tion à laquelle on s’interesse : la gestion des feux de circulation. Puis on passera à l’application
en programmant des simulations de tels systèmes avec scilab. On implémentera également une
interface graphique rudimentaire.
2 ETUDE THÉORIQUE DES SYSTÈMES D’ATTENTE 4
2 Etude théorique des systèmes d’attente

2.1 Introduction : classification des systèmes d’attente
Les phenomènes d’attente sont classifiés et identifiés selon quatre critères essentiels :
– la distribution des intervalles de temps séparant deux arrivées consécutives de clients dans
le système ; A
– la distribution du temps aléatoire que met le client à recevoir le service (temps de service) ;
B
– le nombre de stations de service disponibles en même temps ; s
– la capacité totale du système (nombre maximum de clients pouvant être présents dans le
système en même temps). N
Un système se décrit donc comme suit : A/B/s/N ; le dernier symbole est supprimé si le
système à une capacité infinie (aucun client ne sera jamais refusé).
On introduit également :
– λ le taux des arrivées (nombre moyen d’arrivées par unité de temps) ;
– λ1 l’intervalle de temps moyen séparant deux arrivées consécutives ;
– µ le taux de service (nombre moyen de clients servis par unité de temps) ;
– µ1 durée moyenne du temps de service.
Dans la suite on s’interesse aux systèmes M/M/1(/∞), où :

– A = M signifie que la distribution des intervalles entre deux arrivées est exponentielle ;
– B = M signifie que la distribution des temps de service est exponentielle ;
– s = 1 signifie qu’un unique poste de service est disponible à la fois ;
– N = ∞ signifie que la capacité du système est infinie (la file d’attente peut s’allonger
autant qu’on veut).
On peut déjà imaginer un début de modélisation au moyen d’un système M/M/1 d’une
situation de traffic routier : le poste de service est le feu de circulation, les clients sont les
voitures qui souhaitent passer, la file d’attente est la chaussée jusqu’au feu.
2.2 Le système d’attente M/M/1

2.2.1 Analyse mathématique
On s’interesse à l’évolution du nombre de clients X(t) présents dans le système à l’instant t
(t≥0). X(t) est un processus stochastique, et en fonction des paramètres du système on cherche
à calculer :
– les probabilités d’état P{X(t) = n} qui définissent le régime transitoire de X(t). Le régime
transitoire est la plupart du temps pénible ou impossible à calculer. Dans le cas des sys-
tèmes M/M/1 les calculs font intervenir les fonctions de Bessel que nous ne connaissons
pas. On ne calculera pas le regime transitoire.
– Le régime stationnaire du processus X(t), c’est à dire les pn = limt→∞ pn (t) = P{X(∞) =
n} (n = 0,1,2,..) par la suite on écrira X = X(∞).
Une fois qu’on a la distribution stationnaire du processus, on peut calculer les caractéristiques
d’exploitation du système :
– le nombre moyen de clients dans le système, L = E[X] ;
– la durée d’attente d’un client ;
– la durée de séjour dans le système (temps d’attente et durée de service) ;
– le taux d’occupation des postes de service ;
– le pourcentage de clients ayant pu être servis (on s’interesse à des systèmes de capacité
infinie donc le problème ne se pose pas) ;
– la durée d’une periode d’activité, c’est à dire l’intervalle de temps pendant lequel il y a
toujours au moins un client dans le système.
2.2.2 Regime transitoire

Bien que le régime transitoire soit difficile à calculer, grâce aux propriétés du processus de
Poisson et de la loi exponentielle on obtient des résultats necessaires au calcul du régime sta-
tionnaire.
Nous avons pour un petit intervalle de temps ∆t les probabilités suivantes :

– P(exactement une arrivée pendant ∆t) = λ∆t + o(∆t)
– P(aucune arrivée pendant ∆t) = 1 − λ∆t + o(∆t)
– P(2 arrivées ou plus pendant ∆t) = o(∆t)
– P(exactement un départ pendant ∆t | X(t) ≥ 1) = µ∆t + o(∆t)
– P(aucun départ pendant ∆t | X(t) ≥ 1) = 1 − µ∆t + o(∆t)
– P(2 départs ou plus pendant ∆t) = o(∆t)
On note pij (∆t) = P(X(t + ∆t) = j | X(t) = i) la probabilité conditionnelle que X(t) fasse
une trainsition de i vers j pendant la durée ∆t. Ces probabilités de transition ne dépendent pas
de l’instant t, uniquement de ∆t.
On exprime ces probabilités :
• pn,n+1 (∆t) = P(exactement une arrivée pendant ∆t) × P(aucun départ pendant ∆t | X(t) ≥ 1)
= (λ∆t + o(∆t)) × (1 − µ∆t + o(∆t))
= (λ∆t) × (1 − µ∆t) + o(∆t)
= λ∆t + o(∆t)
• pn,n (∆t) = P(exactement une arrivée pendant ∆t) × P(exactement un départ pendant ∆t | X(t) ≥ 1)
+ P(aucune arrivée pendant ∆t) × P(aucun départ pendant ∆t | X(t) ≥ 1)
= λ∆t.µ∆t + (1 − λ∆t)(1 − µ∆t) + o(∆t)
= 1 − (λ + µ)∆t + o(∆t) (n ≥ 1)
• p0,0 (∆t) = P(aucune arrivée pendant ∆t)
= 1 − λ∆t + o(∆t)
• pn+1,n (∆t) = P(aucune arrivée pendant ∆t) × P(un départ pendant ∆t | X(t) ≥ 1)
= (1 − λ∆t).µ∆t + o(∆t)
= µ∆t + o(∆t) (n ≥ 0)
• pn,m (∆t) = o(∆t) |m − n| ≥ 2
La dernière ligne signifie qu’à partir d’un etat donné n, le processus ne peut donc que passer à
l’un des états voisins n + 1 et n − 1 ou rester sur place.
Pour exprimer les probabilités d’état pn (t) on utilise la formule des probabilités totales
P(A) = i∈I P(A|Bi )P(Bi ) ce qui donne ici et pour n ≥ 1 :
P
∞
X
pn (t + ∆t) = pi (t).pi,n (∆t)
i=0
= pn−1 (t).λ∆t + pn (t)[1 − (λ + µ)∆t] + pn+1 (t).µ∆t + o(∆t)
On obtient donc :
pn (t+∆t)−pn (t)
∆t = −(λ + µ).pn (t) + λ.pn−1 (t) + µ.pn+1 (t) + o(∆t).∆t
Ce qui donne, en faisant tendre ∆t vers 0 :

p0n (t) = −(λ + µ).pn (t) + λ.pn−1 (t) + µ.pn+1 (t)
p00 (t) = −λ.p0 (t) + µ.p1 (t) (même raisonnement, avec n = 0)
Ces equations sont nommées equations différentielles de Kolmogorov ; ici leur résolution fait
intervenir les fonctions de Bessel qui dépassent le cadre de nos compétences et de ce TER.
2.2.3 Regime stationnaire

Dans le système d’équations de Kolmogorov et lorsqu’on fait tendre t vers l’infini, on a les
résultats (admis) suivants :
lim pn (t) = pn
t→∞
lim p0 (t) =0
t→∞ n
Ce qui permet d’obtenir le système :

µ.p1 = λ.p0
λ.pn−1 + µ.pn+1 = (λ + µ).pn (n = 1, 2, ...)
∞
X
pn = 1
n=0
En additionnant, on obtient
µ.pn+1 = λ.pn
D’où
λ
pn = p0 .( )n
µ
∞ ∞
X X λ
Ce qui donne, avec λ < µ : 1 = pn ⇐⇒ 1 = p0 . ( )n
n=0 n=0
µ
1
⇐⇒ 1 = p0 . λ
1− µ
λ
⇐⇒ p0 = 1 −
µ
D’où
λ λ n
pn = (1 − ).( )
µ µ
On constate que le régime stationnaire du système d’attente M/M/1 est gouverné par la vari-
ante de loi géométrique de paramètre 1 − µλ .
REMARQUE : Q = µλ (= 1−p0 ) est appelé coefficient d’utilisation du système, ou intensité

du traffic. Q exprime le nombre moyen d’arrivées par durée moyenne de service, c’est aussi la
probabilité d’occupation de la station de service. Si Q > 1, cela signifie qu’il y a en moyenne plus
d’arrivées que de clients servis, et le système s’engorge (la longueur de la file d’attente dépasse
toute limite en stationnaire). On conservera cette notation dans la suite
2.3 Caractéristiques d’exploitation du système M/M/1

2.3.1 Définitions, formules de Little
Une fois qu’on a le régime stationnaire, on s’intéresse à différentes quantités qui permettent
de juger du comportement du système :
– L = E[X] le nombre moyen de clients dans le système ;
– Lq le nombre moyen de clients dans la file d’attente ;
– W temps de séjour moyen d’un client dans le système ;
– Wq temps d’attente moyen d’un client ;
– Wq ∗ temps d’attente moyen d’un client obligé d’attendre.
Ces grandeurs sont liées entre elles par les relations suivantes :
L = λe .W
Lq = λe .Wq
1
W = Wq +
µ
λe
L = Lq +
µ
Où λe est le taux d’entrée des clients dans le système. Dans le cas du système M/M/1,
λe = λ car la capacité d’accueil est infinie. Les deux premières relations sont appelées formules
de Little.
2.3.2 Calcul des caractéristiques

∞
X
• L = E(X) = n.pn
n=0
∞
X λ λ
= p0 . n.( )n on pose % =
n=0
µ µ
∞
X
= (1 − %). n.%n
n=0
∞
%n )0 .%
X
= (1 − %).(
n=0
1
= (1 − %).%.
(1 − %)2
λ
=
µ−λ
∞
(
0 si X = 0 X
• Xq = Lq = E(Xq ) = (n − 1).pn
X − 1 si X > 1 n=1
∞
%n−1 )0
X
2
= (1 − %).% .(
n=1
λ2
=
µ.(µ − λ)
Lq λ
• Wq = λ = µ.(µ−λ)
1 1
• W = Wq + µ = µ−λ
2.4 Une simulation

(En annexe le code du simulateur de systèmes M/M/1)
Le principe de l’algorithme est de calculer le nombre d’arrivées pendant qu’un client se fait
servir (première boucle while) puis de calculer le nombre de départs entre deux arrivées (deux-
ième boucle while).
On va tracer différentes allures de trajectoires pour le nombre de clients dans le système en

fonction de la valeur du coefficient d’utilisation.
2.4.1 Q>1
Si le coefficient d’utilisation est strictement supérieur à 1 (ici λ = 3, µ = 1.7), il n’y a pas
de régime stationnaire, le système s’engorge et le nombre de clients présents dans le système
augmente sans arrêt.
La trajectoire de X
2.4.2 Q=1
Si Q = 1 (ici λ = 2, µ = 2), le système commence à se stabiliser : il n’y a plus d’engorge-
ment, la file d’attente ne fait pas que augmenter. Néanmoins il est difficile de parler de régime
stationnaire ; le système est en régime critique.
Plusieurs trajectoires de X
On a tracé plusieurs courbes pour illustrer le fait que les trajectoires peuvent être bornées
(plus d’engorgement). Cependant on ne peut pas vraiment prévoir avec précision le nombre de
clients dans le système à un moment donné.
2.4.3 Q<1
Si Q < 1 (ici λ = 1.7, µ = 3), le système admet un régime stationnaire. En plus des deux
graphiques similaires aux sections précédentes, on inclut un histogramme de Xt qui montre
une distribution géométrique conformément aux résultats théoriques (c.f. 2.2.3), ainsi qu’une
trajectoire avec un état initial différent (X0 = 50), où l’on voit qu’en environ 50 unités de temps
on revient au régime stationnaire.
La vitesse à laquelle le système revient à une trajectoire classique dépend de la valeur de Q :
plus Q est proche de zéro plus le système revient vite à une trajectoire qui ne prend plus en
compte les conditions initiales.
Condition initiale : X0 = 0
Condition initiale : X0 = 50
Un histogramme où l’on reconnaît une distribution géométrique

3 LA SITUATION ROUTIÈRE DE DANIEL FLIPO 12
3 La situation routière de Daniel Flipo

3.1 Introduction et description du modèle
Nous avons travaillé sur un document réalisé par Daniel Flipo de l’UFR mathématiques pures
et appliquées de Lille, qui traite d’une situation routière basique se rapprochant des systèmes
M/M/1. Le modèle est le suivant :
– La route est une voie à deux directions en ligne droite

– Un entrepreneur souhaite effectuer des réparations sur une des voies, il va devoir faire un
chantier qui bloquera la voie concernée sur une certaine longueur
– il installe des feux tricolores de part et d’autre du chantier, permettant à chaque file de
passer alternativement le chantier sur la file restante
Les paramètres du modèle sont :

– L la longueur du chantier (en m)
– λ1 , λ2 les paramètres des processus de Poisson modélisant les arrivées de véhicules dans
un sens et dans l’autre
– v la vitesse des véhicules (en m/s)
– g1 , g2 la durée durant laquelle chaque feu est au vert / au rouge (en s)
– K1 , K2 le nombre de voitures que l’on veut laisser passer dans chaque sens
– a le temps qu’une voiture met à démarrer (en s)
3.2 Cycle des feux, engorgement, contraintes

3.2.1 Cycle des feux
Un cycle des feux se déroule de la façon suivante :
– à l’instant 0 le feu 1 passe au vert
– à l’instant d1 il passe au rouge
– à l’instant d1 + Lv (le temps qu’il faut pour évacuer la dernière voiture passée au feu vert
de la zone du chantier) le feu 2 passe au vert
– à l’instant d1 + Lv + d2 le feu 2 passe au rouge
– à l’instant d1 + Lv + d2 + Lv le cycle est fini, on revient à l’instant zéro
3.2.2 Engorgement, contraintes

Si on veut faire passer K véhicules dans un sens, on doit laisser le feu au vert pendant un
laps de temps au moins égal à a.K, ce qui donne ici
(
d1 ≥ a.K1
d2 ≥ a.K2
Le risque principal d’un mauvais ajustement des paramètres des feux est une situation où la
longueur de la file d’attente d’un des feux augmente plus qu’elle ne réduit ; sa longueur augmente
sans borne et le système s’engorge. Dans ce modèle M. Flipo suggère que l’engorgement peut
s’éviter en respectant ces inégalités :
(
d1 ≥ a.λ1 .(d1 + d2 + 2 ∗ Lv )
d2 ≥ a.λ2 .(d1 + d2 + 2 ∗ Lv )
Il considère ici que la durée pendant laquelle un feu est au vert doit être au moins égale à
la durée laissant passer le nombre moyen de véhicules arrivés pendant un cycle. Il n’y a donc
théoriquement que très peu de chance que le système s’engorge, il faudrait que le flux d’arrivée
se comporte pendant longtemps largement au dessus sa moyenne.
On peut discuter le fait que ces différentes minorations de d1 et d2 ne prennent pas en compte
la distance entre le feu et le véhicule qui démarre, l’auteur considérant que chaque voiture dé-
marre directement du feu.
Ceci est contrebalancé par le fait que le coefficient appliqué à a est la durée totale d’un cycle
(le feu reste au vert assez longtemps pour laisser passer le nombre théorique moyen d’arrivants
pendant la durée qu’il passe au rouge ET au vert). Néanmoins dans certaines simulations on a
rencontré des (rares) cas où ces inégalités s’avèrent insuffisantes.
On pourra aussi (par exemple) influencer le fonctionnement du système dans l’autre sens en
augmentant artificiellement le temps a de réaction d’un automobiliste avant de démarrer afin de
prendre en compte la distance moyenne qui le sépare du feu dans la file d’attente.
3.3 La question de l’estimation des paramètres

On se pose la question de l’estimation des paramètres du traffic à partir de données réelles.
On peut demander aux enquêteurs sur le terrain de :
– relever les intervalles de temps séparant les passages de deux véhicules consécutifs ou bien
– compter à intervalles réguliers (une minute par exemple) le nombre de véhicules qui passent
dans l’intervalle.
Dans le premier cas on sait que les instants d’arrivée suivent une loi exponentielle de
paramètre λ, il s’agit donc d’estimer ce paramètre. Pour cela on utilise la méthode du max-
imum de vraisemblance :
Pn
−λxi
L(x1 , ..., xi , ..., xn ; λ) = ni=1 λe −λxi n Qn −λxi = λn e
Q
Pn = λ i=1 e i=1
−λ x
L(x1 , ..., xi , ..., xn ; λ) = λn e i=1 i
Pn
ln L(x1 , ..., xi , ..., xn ; λ) = ln λn e−λ i=1 xi
ln L(x1 , ..., xi , ..., xn ; λ) = n ln λ − λ ni=1 xi
P
∂ ln L(x1 ,...,xi ,...,xn ;λ n Pn

∂λ = 0 ⇐⇒ λ − i=1 xi =0
D’où finalement, λ̂ = Pnn xi

= 1
P1n
xi
= 1
X̄n
i=1 n i=1
∂ 2 ln L(x1 ,...,xi ,...,xn ;λ)

(on a bien ∂λ2
= − λn2 ≤ 0)
Cet estimateur est problématique car il est biaisé.
Dans le second cas, le nombre de voitures passées à intervalles réguliers suit une loi de Poisson,
dont l’estimateur par la méthode du maximum de vraissemblance est sans biais. On le calcule :
x
L(x1 , ..., xi , ..., xn ; λ) = ni=1 e−λ λxi i!
Q
x
L(x1 , ..., xi , ..., xn ; λ) = e−λn ni=1 λxi i!
Q
x
ln L(x1 , ..., xi , ..., xn ; λ) = ln e−λn + ln ni=1 λxi i!
Q
x
ln L(x1 , ..., xi , ..., xn ; λ) = −λn + ni=1 ln λxi i!
P
ln L(x1 , ..., xi , ..., xn ; λ) = −λn + ln λ i=1 xi − ni=1 ln(xi !)

Pn P
Pn
∂ ln L(x1 ,...,xi ,...,xn ;λ) xi
∂λ Pn = 0 ⇐⇒ −n + i=1
λ =0
x
i=1 i
on a donc λ̂ = n = X̄n
Pn
∂ 2 ln L(x1 ,...,xi ,...,xn ;λ) xi
(on a bien ∂λ2
=− i=1
λ2
≤0)
Cet estimateur n’est pas biaisé ce qui est un avantage par rapport à la première méthode de
mesure. Néanmoins on fait essentiellement la même chose, ces méthodes se valent.
3.4 Simulation
La fonction scilab suivante permet de calculer la trajectoire du nombre de voitures présents
au feu 1 à chaque début de cycle (au moment où le feu passe au vert pour eux). Le modèle est
symétrique pour le feu 2.
function X = traj (l,lambda,d1,d2,vit,a,n,ci)

// n nombre de pas
// ci condition initiale
// l longeur du chantier en km
//lambda nb voitures/min moyen
//d1 duré du feu vert 1 en min
//d2 durée du feu vert 2 en min
//vit vitesse des véhicules en km/min
//a temps moyen de démarrage d’une voiture en min
k = floor(d1/a); //le nombre de voitures qui passe le feu pendant un cycle

T = zeros(1,n); //contient la trajectoire
T(1)=ci; //valeur de départ
for i=2:(n)
P = grand(1,1,’poi’,lambda*d1) + T(i-1) - k;
if P < 0 then P = 0
end
T(i)= P + grand(1,1,’poi’,lambda*(d2+(2*l/vit)));
end
X=T
endfunction
Deux exemples de trajectoires données avec ce modèle. (1)

(l = 3/5 ; lambda = 4 ; d1 =6/5 ; d2 = 9/10 ; vit = 1/2 ; a = 1/15 ; n = 500 ; ci = 80 ;)
Il est sensé de se poser la question de l’influence des différents paramètres sur ce modèle : que
se passe-t-il si on modifie la vitesse des voitures ? La durée d’un des feux ? Le temps de réaction
des automobilistes ? La longueur du chantier ? On va changer un paramètre à la fois à partir de
la paramétrisation donnée ci-dessus.
Une trajectoire avec les mêmes paramètres qu’au dessus, à part la vitesse des voitures qu’on
double.
(l = 3/5 ; lambda = 4 ; d1 =6/5 ; d2 = 9/10 ; vit = 1 ; a = 1/15 ; n = 500 ; ci = 80 ;) (2)
La vitesse des voitures a une grande influence sur la stabilité du système : si elles roulent suff-
isamment vite la file d’attente n’a pas le temps de s’allonger. Contrairement à la paramétrisation
précédente où l’on voit que deux trajectoires peuvent avoir des allures tout à fait différentes, ici
elles ont toutes la forme de celle représentée ci-dessus.
Il est intéressant de constater que doubler la vitesse des voitures a exactement le même effet
sur le système que diviser par deux la longueur du chantier. En effet parcourir une distance à
une vitesse équivaut en temps à parcourir la moitié de cette distance à la moitié de la vitesse.
Les effets de la vitesse et de la longueur du chantier sont donc liés. Cela est représenté mathé-
L
matiquement par la présence d’un coefficient vit dans le modèle.
Les trajectoires ont également cette allure si :

– On double la durée du feu 1 (la file qu’on modélise a donc beaucoup plus de temps pour
s’écouler)
– On divise par deux la durée du feu 2 (la file qu’on modélise passe moins de temps à
accumuler des voitures sans pouvoir les évacuer)
– On divise par deux lambda : deux fois moins de voitures arrivent à la file par minute en
moyenne
– On divise par deux le temps de démarrage des automobilistes
Pour faire l’analogie avec les systèmes M/M/1, on peut dire que la figure (1) représente le
régime critique du système : il n’y a pas d’engorgement systématique, mais les trajectoires sont
très différentes entre elles. La figure (2) représente le régime stationnaire : le système revient
vite depuis ses conditions initiales à un état où le nombre de voitures à la file est stable et
suffisamment proche de zéro.
Si l’on fait l’inverse des actions ci-dessus (ie si on divise par deux la vitesse, ou la durée du
feu 1, etc) on obtient la troisième allure de trajectoires qu’on peut rencontrer avec ce système :
la file du feu augmente sans arrêt, le système est complètement instable.
3.5 Amélioration du modèle

Dans les simulations précédentes, le nombre nombre moyen d’arrivées par minute reste fixe
(c’ est le paramètre λ). Evidemment, ce modèle n’est pas réaliste ! C’est pourquoi on a décidé
de faire des simulations en utilisant le même modèle que précedemment sauf que l’on fait varier
le paramètre lambda au cours du temps. Voici un exemple de fonction qui représente le nombre
d’arrivées par minute en fonction du temps en heure :
On peut encore améliorer cette fonction en construisant une spline qui passe par les points
où la fonction en escalier change de valeur.
La spline (courbe verte) nous permet de simuler le nombre de véhicules présents au debut
de chaque cycle durant toute une journée.
On observe maintenant des courbes du type :
Ce graphique montre le nombre de voitures dans la file d’attente en fonction des heures de la
journée
Ce modèle représente plus fidèlemment la réalité, avec des pics de fréquentation et des heures
creuses.
4 ANNEXE : CODES SCILAB 19
3.6 Le modèle à deux voies

La fonction traj ne modélise que l’état d’un des feux. Donc on l’adapte pour faire un modèle
à deux voies comme celui décrit par M. Flipo.
Bleu clair : route, bleu-vert : chantier, ronds noirs : feux
On modélise le nombre de voitures qui attendent à chaque feu au début d’un cycle des feux.
(Le début d’un cycle est le moment où le feu 1 passe au vert).
Pour observer le comportement du système, plutot que de simplement tracer des trajectoires
on implemente une interface graphique rudimentaire avec scilab (code en annexe). Le mod-
èle prend en compte trois types de véhicules à l’encombrement différent, et on s’intéresse à la
longueur des files.
On a deux variantes : soit on va afficher tous les cycles des feux contenus dans une journée (en
faisant varier les paramètres avec la fonction spline ci dessus), soit on reste avec des paramètres
fixes et on simule un nombre de cycles voulu.
On anime l’image ci dessus en traçant les différentes files à chaque début de cycle. L’interface
comprend également une légende et précise les longueurs de chaque file, et l’heure de la journée/le
cycle modélisé. (On pourra éxécuter le programme prévu à cet effet)
4 Annexe : codes scilab

4.1 Loader.sce
loader.sce - le fichier à executer pour démarrer le programme ; il faudra intervenir sur la
commande cd au début pour que scilab trouve les fichiers à executer.
//programme de lancement
cd("Documents/TER/PROGRAMME") //il faut changer le repertoire courant,

//pour accèder à celui où sont les fichiers
usecanvas(%f);
//on fait choisir à l’utilisateur le modèle qu’il souhaite executer

choice1 = 0;
choice1 = x_dialog([’Choisissez un modèle’ ; ’1 : système MM1’ ;
’2 : situation Flipo’],’0’);
choice1 = strtod(choice1);
//en fonction du choix on execute différents fichiers/fonctions
if choice1 == 1 then
//MM1
//on demande à l’utilisateur les constantes pour le système MM1
lambda_mm1 = x_dialog([’Choisissez la valeur de lambda,’ ; ’paramètre de la loi

exponentielle’ ; ’des durées séparant les arrivées’ ;
’des utilisateurs dans le système’],’2’);
mu_mm1 = x_dialog([’Choisissez la valeur de mu,’ ; ’paramètre de la loi exponentielle’
; ’des durées de service’], ’1.7’);
a_mm1 = x_dialog([’Valeur de la condition initiale’;’(nombre d utilisateurs
dans le système au départ)’],’5’);
n_mm1 = x_dialog(["Nombre d’’iterations (>0)"],’100’);
exec(’MM1.sci’,-1); //fonction pour ce cas

MM1(strtod(lambda_mm1),strtod(mu_mm1),strtod(a_mm1),strtod(n_mm1));
elseif choice1 == 2 then
//FLIPO
//on choisit une variante
choice2 = x_dialog([’Choisissez une variante’ ; ’1 : paramètres fixes’
; ’2 : paramètres variables’],’0’);
choice2 = strtod(choice2);
//les fichiers communs aux variantes

exec(’longueur.sci’,-1);
exec(’trajplot.sci’,-1);
if choice2 == 1 then
//les fonctions pour la variante paramètres fixes

exec(’trajgraph.sci’,-1);
exec(’trajanim.sci’,-1);
//FLIPO - paramètres fixes

//CONSTANTES (on demande)
l_mm1 = x_dialog([’Longueur du chantier (en km)’],’0.6’);

lambda1_mm1 = x_dialog([’Nombre moyen d utilisateurs qui arrivent’;
’par minute au feu 1’],’3’);
lambda2_mm1 = x_dialog([’Nombre moyen d utilisateurs qui arrivent’;
’par minute au feu 2’],’3’);
d1_mm1 = x_dialog([’Durée pdt laquelle le’;’feu 1 reste au vert (minutes)’]
,’1.2’);
d2_mm1 = x_dialog([’Durée pdt laquelle le’;’feu 2 reste au vert (minutes)’]
,’0.9’);
vit_mm1 = x_dialog([’Vitesse des voitures (km/min)’],’0.5’);
a_mm1 = x_dialog([’Temps de démarrage des voitures (min)’],’0.067’);
ci1_mm1 = x_dialog([’Nombre de véhicules presents au départ’;

’dans la file 1’],’3’);
ci2_mm1 = x_dialog([’Nombre de véhicules presents au départ’;
’dans la file 2’],’4’);
n_mm1 = x_dialog([’Nombre de cycles des feux à modéliser’],’20’);
//on crée la liste des états

LL = trajgraph(strtod(l_mm1),strtod(lambda1_mm1),strtod(lambda2_mm1),
strtod(d1_mm1),strtod(d2_mm1),strtod(vit_mm1),
strtod(a_mm1),strtod(n_mm1),strtod(ci1_mm1),strtod(ci2_mm1));
//on fait l’animation
trajanim(LL,1,strtod(n_mm1));
elseif choice2 == 2 then
//variante à paramètres variables

//les fichiers pour la variante à paramètres variables
exec(’traj.sci’,-1);
exec(’traj_journee.sci’,-1);
exec(’trajgraph_tps.sci’,-1);
exec(’trajanim2.sci’,-1);
//constantes
l_mm1_b = x_dialog([’Longueur du chantier (en km)’],’0.6’);
d1_mm1_b = x_dialog([’Durée pdt laquelle le’;
’feu 1 reste au vert (minutes)’],’1.2’);
d2_mm1_b = x_dialog([’Durée pdt laquelle le’;
’feu 2 reste au vert (minutes)’],’0.9’);
vit_mm1_b = x_dialog([’Vitesse des voitures (km/min)’],’0.5’);
a_mm1_b = x_dialog([’Temps de démarrage des voitures (min)’],’0.067’);
//les fonctions en escalier pour lambda

h1 = [0.1 0.1 0.2 0.5 1 1.3 4 3.6 2.2 1.2 1 1.2
3.8 3.2 1.2 1.2 2 3.8 4.3 2.1 1.2 0.8 0.3 0.2];
h2=h1*0.85;
//on calcule le temps d’un cycle et le nombre de cycles en une journée

tps_cycle = (strtod(d1_mm1_b)+strtod(d2_mm1_b)+
2*strtod(l_mm1_b)/strtod(vit_mm1_b))/60
nb_cycles = floor(24/tps_cycle);
//on fait la liste des états et l’animation

LLL = trajgraph_tps(strtod(l_mm1_b),h1,h2,strtod(d1_mm1_b),
strtod(d2_mm1_b),strtod(vit_mm1_b),strtod(a_mm1_b),0,0);
trajanim2(LLL,1,nb_cycles-1,tps_cycle);
end
end
4.2 MM1.sci
MM1.sci - fonction de simulation du système M/M/1
//// Simulation système M/M/1 (temps continu)
// Cette fonction simule un système M/M/1 en temps continu
function []=MM1(lambda,mu,a,n)
// lambda, nombre moyen de clients/unité de temps
// mu, temps moyen de service
// a, nombre de clients dans le système à l’instant 0
// n, nombre d’itérations.
// on construit le vecteur des arrivées y

y = grand(1,n*10,’exp’,1/lambda);
y = cumsum(y);
// on construit le vecteur des temps de service z

z = grand(1,n*10,’exp’,1/mu);
X = [a]; //on initialise X, le nombre de personne (CI)

tps = [0];// on initialise le vecteur temps
p = 1; // compteurs
k = p;
for i=1:n
// on regarde combien de personnes arrivent pendant qu’une personne se fait servir

while (y(p) < (y(k)+z(k))&(p < n))
X = [X X($)+1];
tps = [tps y(p)] ;
p = p+1;
end
d = k ;
l = X($-1); // on regarde combien de clients
//sont dans le système, donc il ne pourra pas avoir plus de l départs
//// on regarde combien de personnes partent alors qu’il n’y a pas d’arrivées
while (sum(z(k:d)) < y(p)-y(k))& (d<n) & (l>=0)
X = [X ,X($)-1] ;
tps = [tps y(k)+sum(z(k:d))];
d = d+1;
l = l-1;
end
k = p;
end
// on trace la trajectoire.
plot2d2(tps,X)
xlabel("Temps");
ylabel("Clients");
endfunction
4.3 Longueur.sci
longueur.sci - fonction pour calculer la longueur des files d’attente (pour le modèle de Flipo)
// Longueur : calcul la longueur de la file d’attente pour chaque cycle.
function L = longueur(T)
// L matrice 2,n des longueurs cycle après cycle de chaque file

// T , liste de type trajgraph
n = size(T(1));
L = zeros(2,n);
for i = 1:n
L1 = T(1)(i);
L2 = T(2)(i);
// on calcule la longueur de la file 1 pour chaque cycle

for j =1:length(L1)
if L1(j)==1 then
L(1,i) = L(1,i) + 5; // une voiture fait 5m
elseif L1(j)==2 then // un bus fait 10 m
L(1,i) = L(1,i) + 10; // un semi-remorque fait 20 m
else
L(1,i) = L(1,i) +20;
end
end
// on calcule la longueur de la file 2 pour chaque cycle

for j =1:length(L2)
if L2(j)==1 then
L(2,i) = L(2,i) + 5;
elseif L2(j)==2 then
L(2,i) = L(2,i) + 10;
else
L(2,i) = L(2,i) + 20;
end
end
end
endfunction
4.4 Trajplot.sci
trajplot.sci - fonction pour tracer les files d’attente
//trajplot : avec une liste d’états du système on fait

// un plot du décor et les files pour un état i
function []=trajplot(L,i)
//IN : L - une liste créée par la fonction trajgraph ;
// i - l’état que l’on souhaite représenter
// i doit etre inferieur ou égal au nombre d’états qu’on a simulé
//OUT : rien, on trace un plot
data1 = L(1)(i);
data2 = L(2)(i);
n1 = length(data1);
n2 = length(data2);
//coordonnées de départ pour le tracage des voitures

x1 = -200;
y1 = 0;
x2 = 200;
y2 = 30;
//on va tracer les voitures présentes sur la file 1

if n1 <> 0 then
for j = 1:n1
if data1(j) == 1 then
xset("color",8);
x1 = x1 - 5;
xfrect(x1+1,y1-5,3,20);
elseif data1(j) == 2 then
xset("color",6);
x1 = x1 - 10;
xfrect(x1+1,y1-5,8,20);
else
xset("color",22);
x1 = x1 - 20;
xfrect(x1+1,y1-5,18,20);
end
end
end
//dans la file 2
if n2 <> 0 then
for k = 1:n2
if data2(k) == 1 then
xset("color",8);
xfrect(x2+1,y2-5,3,20);
x2 = x2 + 5;
elseif data2(k) == 2 then
xset("color",6);
xfrect(x2+1,y2-5,8,20);
x2 = x2 + 10;
else
xset("color",22);
xfrect(x2+1,y2-5,18,20);
x2 = x2 + 20;
end
end
end
endfunction
4.5 Trajgraph.sci
trajgraph.sci - fonction qui génère des listes d’états pour les deux files d’attente du modèle
de Flipo, prêtes à être tracées
function L=trajgraph(l,lambda1,lambda2,d1,d2,vit,a,n,ci1,ci2)
//L = liste des états de chaque file : liste de deux listes de tableaux
//lambda1, lambda2 : nombre moyen d’arrivées par minutes à chaque feu
//d1, d2 : durées pdt lesquelles chaque feu reste au vert
//a : temps de démarrage
//n : nombre d’états
//ci1,ci2 : conditions initiales (nombre de voitures ds chaque file au début)
k1 = floor(d1/a); //les grandeurs de chaque feu

k2 = floor(d2/a);
T1 = zeros(1,n); //on stocke quand meme les anciens modeles de traj
T2 = zeros(1,n);
T1(1) = ci1; //conditions initiales

T2(1) = ci2;
E1 = []; //on va stocker les types de véhicules présents a la file 1

E2 = []; //à la file 2
//on traite le cas de départ si il y en a un, pour chaque file

if ci1 <> 0 then
Y = grand(1,ci1,’unf’,0,1);
for i = 1:ci1
if Y(i) < 0.6 then
E1 = [E1 1]; //1 représente une voiture

elseif Y(i) < 0.9 then
E1 = [E1 2]; //2 un bus
else
E1 = [E1 3]; //3 semi remorque
end
end
end
if ci2 <> 0 then

Y = grand(1,ci2,’unf’,0,1);
for i = 1:ci2
if Y(i) < 0.6 then
E2 = [E2 1];
elseif Y(i) < 0.9 then
E2 = [E2 2];
else
E2 = [E2 3];
end
end
end
//on va stocker chaque E1 et E2 dans des listes

L1 = list(E1);
L2 = list(E2);
//on déroule les trajectoires

for i=2:(n)
//FILE 1
Y1 = grand(1,1,’poi’,lambda1*d1);
P1 = Y1 + T1(i-1) - k1;
//on ajoute les nouveaux véhicules qui arrivent pdt le feu vert
//au début de la file
rnd = grand(1,Y1,’unf’,0,1);
for i = 1:Y1
if rnd(i) < 0.6 then
E1 = [1 E1];
elseif rnd(i) < 0.9 then
E1 = [2 E1];
else
E1 = [3 E1];
end
end
//si plus de véhicules sont passés que le nb présent il n’y en a plus

if k1 >= length(E1) then
E1 = [];
//sinon on enlève ceux de la fin
else
for i = 1:k1
E1($) = [];
end
end
if P1 < 0 then
P1 = 0 ;
end
Y1b = grand(1,1,’poi’,lambda1*(d2+(2*l/vit)));
T1(i)= P1 + Y1b;
rndb = grand(1,Y1b,’unf’,0,1);
for i = 1:Y1b
if rndb(i) < 0.6 then
E1 = [1 E1];
elseif rndb(i) < 0.9 then
E1 = [2 E1];
else
E1 = [3 E1];
end
end
L1($+1) = E1;
end
for i=2:n
//FILE 2
Y2 = grand(1,1,’poi’,lambda2*d2);
P2 = Y2 + T2(i-1) - k2;
//on ajoute les nouveaux véhicules qui arrivent pdt le feu vert
//au début de la file
rnd2 = grand(1,Y2,’unf’,0,1);
for i = 1:Y2
if rnd2(i) < 0.6 then
E2 = [1 E2];
elseif rnd2(i) < 0.9 then
E2 = [2 E2];
else
E2 = [3 E2];
end
end
//si plus de véhicules sont passés que le nb présent il n’y en a plus

if k2 > length(E2) then
E2 = [];
//sinon on enlève ceux de la fin
else
for i = 1:k2
E2($) = [];
end
end
if P2 < 0 then
P2 = 0 ;
end
Y2b = grand(1,1,’poi’,lambda2*(d1+(2*l/vit)));
T2(i)= P2 + Y2b;
rnd2b = grand(1,Y2b,’unf’,0,1);
for i = 1:Y2b
if rnd2b(i) < 0.6 then
E2 = [1 E2];
elseif rnd2b(i) < 0.9 then
E2 = [2 E2];
else
E2 = [3 E2];
end
end
L2($+1) = E2;
end
L = list(L1,L2);
endfunction
4.6 Trajanim.sci
trajanim.sci - la fonction qui génère les animations avec trajplot et trajgraph
//fonction pour animer les plots de trajectoires
function []=trajanim(L,i1,i2)
//out : rien, on fait des plot

//in : L une liste créée par la fonction trajgraph
//i1 = etat de départ, i2 = etat final
//va réaliser une animation où les états de i1 à i2 sont plottés successivement
//on doit avoir i1<i2, sinon c’est pas drole
//recupérer les longueurs de file
long = longueur(L);
//DEPART : PLOT DU DECOR
//modifier propriétés graphiques

f = gcf(); //get current figure
a = gca(); //get current axes
//fenetre
plot2d(0,0,0,rect=[-1000,-150,1000,150],frameflag=3);
a.axes_visible = "off"; //on cache les axes

f.figure_size= [1800 600]; //on regle la taille
a.margins = [0.01 0.01 0.01 0.01]; //les marges
//les différents elements graphiques

xset("color",12);
xfrect(-1000,30,2000,60);
xset("color",16);
xfrect(-200,30,400,30);
xset("color",1);
xfarc(-220,-30,20,20,0,360*64);
xfarc(200,50,20,20,0,360*64);
xsegs([-200 -200 200 200 -1000 1000],[-30 30 -30 30 0 0],style=1);
//legende
xstring(-800,130,"LEGENDE : blanc = voiture (5m), rose = bus (10m),
violet = semi-remorque (20m)");
xstring(-800,110, "LONGUEUR DE LA FILE 1 : ");
xstring(-800,70, "Numéro de cycle : ");
f.pixmap=’on’; //activer mode pixmap
for j = i1:i2
clf(); //nettoyer buffer
//on refait le décor (obligatoire apparamment..)

f = gcf();
a = gca();
a.axes_visible = "off";
f.figure_size= [1800 600];
a.margins = [0.01 0.01 0.01 0.01];
xset("color",12);
xfrect(-1000,30,2000,60);
xset("color",16);
xfrect(-200,30,400,30);
xset("color",1);
xfarc(-220,-30,20,20,0,360*64);
xfarc(200,50,20,20,0,360*64);
xsegs([-200 -200 200 200 -1000 1000],[-30 30 -30 30 0 0],style=1);

lg1 = string(long(1,j));
js = string(j);
xstring(-800,110, ["LONGUEUR DE LA FILE 1 : " lg1 " m"]);
xstring(-800,70,["Numéro de cycle : " js]);
trajplot(L,j); //on trace les véhicules
show_pixmap(); //on affiche la pixmap
sleep(1000); //on attend une seconde avant de passer à l’étape suivante
end
f.pixmap=’off’ //on arrete le mode pixmap
endfunction
4.7 Traj.sci
traj.sci - la fonction de base pour le modèle de Flipo
function X = traj (l,lambda,d1,d2,vit,a,n,ci)

//X trajectoire du nombre de voitures présentes au feu au début d’un cycle
// n nombre de pas
// ci condition initiale
//lambda nb voitures/min moyen
//a temps de demarrage en min
k = floor(d1/a);
T = zeros(1,n); //contient la trajectoire
T(1)=ci; //valeur de départ
for i=2:(n)
P = grand(1,1,’poi’,lambda*d1) + T(i-1) - k;
if P < 0 then P = 0
end
T(i)= P + grand(1,1,’poi’,lambda*(d2+(2*l/vit)));
end
X=T
endfunction
4.8 Traj_ journee.sci

traj_ journee.sci - adaptation de traj pour faire une trajectoire sur toute la journée en
faisant varier le paramètre
function X =traj_journee(l,h,d1,d2,vit,a)
//X trajectoire du nombre de voitures présentes au feu à chaque debut de cycles
//h fonction qui donne le nombre de vehicules/min en fonction des heures de la journée
//a temps de demarrage en min
tpscycle = (d1+d2+2*l/vit)/60; // durée du temps d’un cycle
ci = 0; // on initialise la condiion iniiale
X = []; // on initialise X
x = linspace(0,23,24);
/////// interpolation de h
P=splin(x,h);
tps = 0;
// on calcule le nombre de voiures en fonction du temps

while tps<24
S=interp(tps,x,h,P); // on récupère le nombre d’arrivées/min

y = traj(l,S,d1,d2,vit,a,2,ci) ;// on calcule prend le nombre de voiture
X = [X y(2)];
ci = y(1);
tps = tps+tpscycle;
end
endfunction
4.9 Trajgraph_ tps.sci

trajgraph_ tps.sci - adaptation de trajgraph pour la version paramètres variants
// Cette fonction à la différence de trajanim, est faite pour simuler

// le nombre de véhicules sur chaque file au cours de la journée
function L=trajgraph_tps(l,h1,h2,d1,d2,vit,a,ci1,ci2)
//L = liste des états de chaque file : liste de deux listes de tableaux
//h1, fonction en escalier qui donne le nombre voitures/min moyen

// durant les heures de la journée pour le feu 1
//h2, fonction en escalier qui donne le nombre voitures/min moyen
//durant les heures de la journée pour le feu 2
//d1, durée du feu 1 en min
//d2, durée du feu 2 en min
//vit, vitesse des véhicules
//a, temps de démarrage
//c1,c2 conditions initiales.
k1 = floor(d1/a); //le nombre de véhicules max qui passent à chaque cycle de chaque feu
k2 = floor(d2/a);
T1(1) = ci1; //conditions initiales

T2(1) = ci2;
E1 = []; //on va stocker les types de véhicules présents a la file 1

E2 = []; //à la file 2
tpscycle = (d1+d2+2*l/vit)/60; // durée du temps d’un cycle
//on va stocker chaque E1 et E2 dans des listes

L1 = list(E1);
L2 = list(E2);
// on simule le nb de véhicules à chaque cycle durant la journée

X1 = traj_journee(l,h1,d1,d2,vit,a);
X2 = traj_journee(l,h2,d1,d2,vit,a);
c1=0; c2=0; //on suppose nul le trafic au début;
nbcycle = 24/tpscycle;
// file 1
for j = 1:nbcycle
n = X1(j)-c1; // nombre de voitures arrivées

rndb = grand(1,n,’unf’,0,1);
// on tire pour voir si on a un camion,voiture,semi-remorque

for i = 1:n
if rndb(i) < 0.6 then
E1 = [1 E1];
elseif rndb(i) < 0.9 then
E1 = [2 E1];
else
E1 = [3 E1];
end
end
// on retire les voitures qui partent

L1($+1) = E1;
if k1>= length(E1) then
E1=[];
else
for i =1:k1
E1($)=[];
end
end
c1 = length(E1);
end
// file 2
for j=1:nbcycle
n = X2(j)- c2; // nombre de voitures arrivées

rnd2b = grand(1,n,’unf’,0,1);
// on tire pour voir si on a un camion,voiture,semi-remorque

for i = 1:n
if rnd2b(i) < 0.6 then
E2 = [1 E2];
elseif rnd2b(i) < 0.9 then
E2 = [2 E2];
else
E2 = [3 E2];
end
end
L2($+1) = E2;
// on retire les voitures qui sont passées .

if k2>= length(E2) then
E2=[];
else
for i =1:k2
E2($)=[];
end
end
c2 = length(E2);
end
L = list(L1,L2);
endfunction
4.10 Trajanim2.sci
trajanim2.sci - variante de trajanim pour le modèle paramètres variants
//fonction pour animer les plots de trajectoires
function []=trajanim2(L,i1,i2,tps)
//out : rien, on fait des plot

//in : L une liste créée par la fonction trajgraph
// i1 = etat de départ, i2 = etat final, tps = durée d’un cycle des feux en h
//va réaliser une animation où les états de i1 à i2 sont plottés successivement
//on doit avoir i1<i2, sinon c’est pas drole
//recupérer les longueurs de file
long = longueur(L);
//DEPART : PLOT DU DECOR
f = gcf();
a = gca();
a.margins = [0.01 0.01 0.01 0.01];
xset("color",12);
xfrect(-1000,30,2000,60);
xset("color",16);
xfrect(-200,30,400,30);
xset("color",1);
xfarc(-220,-30,20,20,0,360*64);
xfarc(200,50,20,20,0,360*64);
xsegs([-200 -200 200 200 -1000 1000],[-30 30 -30 30 0 0],style=1);


xstring(-800,70, "Heure : ");
f.pixmap=’on’; //activer mode pixmap
for j = i1:i2
clf(); //nettoyer buffer
//on refait le décor

f = gcf();
a = gca();
a.margins = [0.01 0.01 0.01 0.01];
xset("color",12);
xfrect(-1000,30,2000,60);
xset("color",16);
xfrect(-200,30,400,30);
xset("color",1);
xfarc(-220,-30,20,20,0,360*64);
xfarc(200,50,20,20,0,360*64);
xsegs([-200 -200 200 200 -1000 1000],[-30 30 -30 30 0 0],style=1);
xstring(-800,130,"LEGENDE : blanc = voiture (5m),

rose = bus (10m), violet = semi-remorque (20m)");
hh = string(j*tps);
xstring(-800,70, ["Heure : " hh]);
trajplot(L,j); //on trace les véhicules
show_pixmap(); //on affiche la pixmap
sleep(500); //on attend une seconde avant de passer à l’étape suivante
end
f.pixmap=’off’ //on arrete le mode pixmap
endfunction

Phénomènes D Attente Et Application À La Gestion Des Feux de Circulation

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Phénomènes D Attente Et Application À La Gestion Des Feux de Circulation

Transféré par

Droits d'auteur :

Formats disponibles

1

Phénomènes d’attente et application à la

Sous la Direction de : PERRUT Anne

Table des matières

2 Etude théorique des systèmes d’attente 4

3 La situation routière de Daniel Flipo 12

4 Annexe : codes scilab 19

On trouve de nombreux exemples de ces phénomènes d’attente dans notre quotidien :

2 Etude théorique des systèmes d’attente

Dans la suite on s’interesse aux systèmes M/M/1(/∞), où :

2.2 Le système d’attente M/M/1

2.2.2 Regime transitoire

Nous avons pour un petit intervalle de temps ∆t les probabilités suivantes :

On exprime ces probabilités :

Ce qui donne, en faisant tendre ∆t vers 0 :

2.2.3 Regime stationnaire

Ce qui permet d’obtenir le système :

REMARQUE : Q = µλ (= 1−p0 ) est appelé coefficient d’utilisation du système, ou intensité

2.3 Caractéristiques d’exploitation du système M/M/1

2.3.2 Calcul des caractéristiques

2.4 Une simulation

On va tracer différentes allures de trajectoires pour le nombre de clients dans le système en

Un histogramme où l’on reconnaît une distribution géométrique

3 La situation routière de Daniel Flipo

– La route est une voie à deux directions en ligne droite

Les paramètres du modèle sont :

3.2 Cycle des feux, engorgement, contraintes

3.2.2 Engorgement, contraintes

3.3 La question de l’estimation des paramètres

∂ ln L(x1 ,...,xi ,...,xn ;λ n Pn

D’où finalement, λ̂ = Pnn xi

∂ 2 ln L(x1 ,...,xi ,...,xn ;λ)

Cet estimateur est problématique car il est biaisé.

ln L(x1 , ..., xi , ..., xn ; λ) = −λn + ln λ i=1 xi − ni=1 ln(xi !)

function X = traj (l,lambda,d1,d2,vit,a,n,ci)

k = floor(d1/a); //le nombre de voitures qui passe le feu pendant un cycle

Deux exemples de trajectoires données avec ce modèle. (1)

Les trajectoires ont également cette allure si :

3.5 Amélioration du modèle

3.6 Le modèle à deux voies

Bleu clair : route, bleu-vert : chantier, ronds noirs : feux

4 Annexe : codes scilab

cd("Documents/TER/PROGRAMME") //il faut changer le repertoire courant,

//on fait choisir à l’utilisateur le modèle qu’il souhaite executer

//en fonction du choix on execute différents fichiers/fonctions

lambda_mm1 = x_dialog([’Choisissez la valeur de lambda,’ ; ’paramètre de la loi

exec(’MM1.sci’,-1); //fonction pour ce cas

elseif choice1 == 2 then

//les fichiers communs aux variantes

//les fonctions pour la variante paramètres fixes

//FLIPO - paramètres fixes

l_mm1 = x_dialog([’Longueur du chantier (en km)’],’0.6’);

ci1_mm1 = x_dialog([’Nombre de véhicules presents au départ’;

//on crée la liste des états

elseif choice2 == 2 then

//variante à paramètres variables

//les fonctions en escalier pour lambda

//on calcule le temps d’un cycle et le nombre de cycles en une journée

//on fait la liste des états et l’animation

//// Simulation système M/M/1 (temps continu)

// Cette fonction simule un système M/M/1 en temps continu

// on construit le vecteur des arrivées y

// on construit le vecteur des temps de service z