Réalisation de modèles de simulation à vocation...

Université Gand

Faculté Sciences de l’ingénieur

Année académique 2005-2006

Unité d’Enseignement et de Recherche

Génie Industriel

Président: prof. dr. ir. H. VAN LANDEGHEM

Réalisation de modèles de simulation à

vocation pédagogique

Par

Reinout MAES

Tuteur: prof. dr. ir. H. VAN LANDEGHEM

(Tuteur industriel: ir. T. LAGABRIELLE

Tuteur enseignant Grenoble: dr. ir. J. GAYON)

Mémoire présenté afin d’obtenir le grade universitaire d’ingénieur civil

II

Remerciements

Je remercie tout spécialement chacun des membres d’1Point2:

Merci d’abord à Timothée, qui, malgré son travail occupant, prenait toujours du temps pour

m’aider et en plus pour lire mon rapport de stage et surtout mon mémoire. Merci à Guillaume et

Jacqueline pour les conseils avisés et la liberté d’action donnée. Ce dernier était essentiel, vu les

difficultés de la combinaison d’un stage et un mémoire. Merci à Christian, le spécialiste

informaticien. Finalement, je remercie tout le monde pour l’accueil aimable.

Je suis très content que j’aie eu la chance de travailler dans une société de service tellement

renommée. C’était l’occasion d’approfondir et de mettre en pratique l’enseignement en simulation

de flux et en recherche opérationnelle.

Je remercie Hendrik Van Landeghem, mon tuteur enseignant à l’université de Gand d’avoir gardé

un œil sur mon mémoire, mon stage et surtout de m’avoir aidé pour résoudre les difficultés que

j’ai rencontrées à aligner les buts des deux.

Je remercie également Jean-Philippe Gayon, mon tuteur enseignant à l’ENSGI pour répondre à

mes questions et pour lire mon rapport et surtout mon mémoire.

Et enfin, un grand merci à Anthony Nastasi et Cécile Damiron d’Imagine That! pour leurs

réponses nombreuses et aimables à toutes mes questions de support technique.

L’auteur donne permission de rendre disponible ce mémoire et de copier parties du mémoire

pour usage personnel à partir de janvier 2007.

Chaque autre usage est du ressort des limites du droit d’auteur, en particulaire en ce qui concerne

à l’obligation de mentionner la source en utilisant les résultats de ce mémoire.

III

Aperçu

Réalisation de modèles de simulation à vocation pédagogique

Par Reinout MAES

Année académique 2005-2006

Université Gand, Faculté Sciences de l’ingénieur

Unité d’Enseignement et de Recherche de Génie Industriel

Président: prof. dr. ir. H. VAN LANDEGHEM

Tuteur: prof. dr. ir. H. VAN LANDEGHEM

(Tuteur industriel: ir. T. LAGABRIELLE

Tuteur enseignant Grenoble: dr. ir. J. GAYON)

Mémoire présenté afin d’obtenir le grade universitaire d’ingénieur civil

Résumé

Dans le cadre du lancement d’une nouvelle version d’Extend, un logiciel de simulation, j’ai effectué des tests Alpha et Beta. En même temps j’ai rédigé une formation pour laquelle j’ai fait des modèles d’exemple et d’exercice. La première partie du mémoire est concentrée autour de ces modèles. La formation est divisée en plusieurs chapitres. Cette structure a été reprise dans le mémoire. Après une introduction en flux discret, les attributs sont considérés. On continue par le flux continu et les bases de données, puis les ressources, les blocs hiérarchiques, les règles de gestion et enfin des exercices de récapitulation. En plus des tests et de la formation, j’ai effectué une étude sur l’exploitation des modèles. Il s’agit de deux outils compris dans Extend : l’analyse de sensibilité et l’optimisateur et un outil que j’ai créé pour exécuter des plans d’expérience via Excel. Cela est fait dans la version précédente du logiciel, parce que la nouvelle n’était pas encore assez stable à ce moment-là.

Mots clef

Extend, Simulation de flux, optimisation, plans d’expérience

IV

Table des matières

Remerciements ............................................................................................................................................II

Aperçu......................................................................................................................................................... III

Table des matières..................................................................................................................................... IV

1 Introduction .........................................................................................................................................1

1.1 Situation.......................................................................................................................................1

1.2 L’entreprise 1Point2 ..................................................................................................................1

1.3 La simulation de flux .................................................................................................................2

1.4 Le logiciel Extend ......................................................................................................................3

1.5 1Point2 et Imagine That Inc. ...................................................................................................4

1.6 Les phases du développement d’un nouveau logiciel ...........................................................5

2 Flux discret...........................................................................................................................................6

2.1 Introduction................................................................................................................................6

2.2 Les modèles.................................................................................................................................7

2.2.1 Interne A.................................................................................................................................8

2.2.2 Interne B .................................................................................................................................9

2.2.3 Aléas de production ............................................................................................................11

2.2.4 Génération d’entités ............................................................................................................12

2.2.5 Pannes ...................................................................................................................................13

2.2.6 Exercice 1 .............................................................................................................................15

3 Attributs..............................................................................................................................................17

3.1 Introduction..............................................................................................................................17

3.2 Modèles......................................................................................................................................17

3.2.1 Rodéo ....................................................................................................................................17

3.2.2 Equation Item ......................................................................................................................19

3.2.3 Peinture .................................................................................................................................20

3.2.4 Retouche A...........................................................................................................................21

3.2.5 Retouche B ...........................................................................................................................22

4 Flux continu .......................................................................................................................................24

4.1 Introduction..............................................................................................................................24

4.2 Modèles......................................................................................................................................24

4.2.1 Discret et continu ................................................................................................................24

4.2.2 Variation débit......................................................................................................................26

V

4.2.3 Four .......................................................................................................................................27

4.2.4 Four-mélangeur....................................................................................................................28

4.2.5 Batch Flux Mixtes A ...........................................................................................................30

4.2.6 Batch flux mixtes B .............................................................................................................32

5 Base de données ................................................................................................................................34

5.1 Introduction..............................................................................................................................34

5.2 Modèles......................................................................................................................................35

5.2.1 Barres glacées .......................................................................................................................35

6 Ressources..........................................................................................................................................38

6.1 Introduction..............................................................................................................................38

6.2 Modèles......................................................................................................................................39

6.2.1 Partage de ressources A......................................................................................................39

6.2.2 Partage de ressources B ......................................................................................................40

6.2.3 Broyeurs ................................................................................................................................41

6.2.4 Broyeurs 2.............................................................................................................................42

7 Les blocs hiérarchiques ....................................................................................................................44

7.1 Introduction..............................................................................................................................44

7.2 Modèles......................................................................................................................................45

7.2.1 Gamme de fabrication ........................................................................................................45

7.2.2 Gamme de fabrication hiérarchique .................................................................................47

8 Règles de gestion de l’atelier ............................................................................................................49

8.1 Introduction..............................................................................................................................49

8.2 Modèles......................................................................................................................................49

8.2.1 Machine de secours 1..........................................................................................................49




8.2.5 Maintenance .........................................................................................................................53

9 Exercices récapitulatifs .....................................................................................................................55

9.1 Introduction..............................................................................................................................55

9.2 Modèles......................................................................................................................................55

9.2.1 Final 1....................................................................................................................................55

9.2.2 Final 2....................................................................................................................................56

9.2.3 Final 3....................................................................................................................................57

VI

10 Exploitation........................................................................................................................................58

10.1 Introduction..............................................................................................................................58

10.2 Analyse de sensibilité ...............................................................................................................59

10.2.1 Introduction.....................................................................................................................59

10.2.2 Exemple des batteries.....................................................................................................59

10.2.3 Application.......................................................................................................................61

10.2.4 Conclusion .......................................................................................................................63

10.3 L'optimisateur ...........................................................................................................................63

10.3.1 Introduction.....................................................................................................................63

10.3.2 L’optimisateur d’Extend ................................................................................................64

10.3.3 Application.......................................................................................................................65

10.3.4 Conclusion .......................................................................................................................69

10.4 Effectuer des plans d’expérience via Excel ..........................................................................69

10.4.1 Introduction.....................................................................................................................69

10.4.2 Lien avec Excel................................................................................................................70

10.4.3 Application : Plan factoriel complet.............................................................................71

10.4.4 Application : Plan factoriel fractionnaire Taguchi .....................................................72

10.4.5 Conclusion .......................................................................................................................78

11 Conclusion .........................................................................................................................................79

Appendices..................................................................................................................................................80

Appendice A : code VBA pour l’exploitation du modèle des batteries.........................................80

Appendice B : code VBA pour l’exploitation du modèle du resto rapide.....................................82

Références ...................................................................................................................................................84

1

1 Introduction

1.1 Situation

Dans ma dernière année à l’université de Gand, j’ai fait un programme d’échange ERASMUS

avec l’ENSGI de Grenoble pendant le deuxième semestre pour faire mon projet de fin d’études.

Dans ce cadre, j’ai effectué un stage au sein de l’entreprise grenobloise 1Point2. Cette société de

service est spécialisée dans la simulation de flux pour l’industrie, en utilisant le logiciel Extend.

Délivrer des formations professionnelles est une partie de sa mission.

Fin 2006, la commercialisation de la nouvelle version d’Extend (V7) est prévue. Comme elle a

une structuration en blocs très différente de celle actuelle (la version 6 ou « V6 »), cela implique

un changement total des formations. Le but du stage était autant la réalisation des formations,

que le test de la nouvelle version. Ce test impliquait une procédure de feed-back rigoureuse pour

signaler les erreurs reproductibles à Imagine That!, concepteur d’Extend, dans chaque phase du

développement de la nouvelle version.

Les tests et la conception des formations étaient essentiels pour 1Point2 et très intéressants pour

moi, mais peu utilisables pour mon mémoire. Pour cette raison, le mémoire est concentré autour

des modèles réalisés dans le cadre des formations. Tous les modèles sont faits dans la version

Beta de V7. Cela implique la confidentialité du mémoire jusqu’à la commercialisation de V7.

Mis à part des tests et de la formation, j’ai effectué une étude sur l’exploitation des modèles. Cela

est fait dans la V6, parce que la V7 n’était pas encore assez stable à ce moment-là.

Après une rapide présentation du contexte du stage, notamment une présentation de l’entreprise

1Point2, de la simulation de flux et du logiciel Extend, nous présenterons les modèles qui ont été

réalisé durant cette période.

1.2 L’entreprise 1Point2

1Point2, TPE créée en 1987, représente sur les pays de l’Europe du Sud l'environnement de

simulation Extend, développé par Imagine That!, ainsi que les modules d’extension associés.

L’activité a débuté avec la traduction de documents techniques. Mais la forte concurrence sur ce

secteur, incita 1Point2 à s’orienter vers la simulation. La présence d’un éditeur de logiciel de

simulation de flux au sein des clients, avait déjà permis de nouer des liens dans ce domaine qui

trouvait alors ses premières applications industrielles. Actuellement, l’essentiel de l’activité de

1Point2 se base sur la simulation de flux et ses applications dans des prestations d’études

industrielles.

2

De nos jours, l’effectif de 1Point2 se chiffre à sept personnes alors que son activité s’est recentrée

entièrement autour de la simulation avec :

• des prestations d'études industrielles basées sur la simulation de flux:

o analyse de rentabilité d'un projet,

o tension des flux, dimensionnement de boucles Kanban,

o dimensionnement d'un investissement, équilibrage de ligne,

o impact industriel de l'aménagement du temps de travail,

o logistique,

o mise en ligne, aide à l’implantation.

• la construction de modèles « clés en main » :

o études de faisabilité,

o bibliothèques de blocs sur mesure,

o liens avec MS Excel et interfaces spécifiques,

o plan d'expérience et analyse des résultats.

• la formation à la simulation et l’utilisation d’Extend.

• la vente du logiciel Extend et de ses modules d’extension.

De manière générale, un quart à un tiers du chiffre d’affaire de 1Point2 provient de la vente de

licences et de la formation, le reste étant issu d’études industrielles ou de la construction de

modèles clés en main.

Une des particularités de 1Point2 provient de la forte disparité entre la taille de ce fournisseur et

celle de la majorité de sa clientèle, qui est essentiellement composée de grands groupes

industriels. On y trouve par exemple : Airbus, Air France, Quick, Procter & Gamble.

1.3 La simulation de flux

Depuis toujours, l’ingénieur a cherché à trouver des solutions à partir d’un modèle avant de les

implanter dans la réalité. Dans ce cadre, la simulation possède un atout déterminant puisqu’elle

permet de modéliser n’importe quel processus, de manière aussi réaliste et aussi fine qu’on le

désire et sans hypothèse d’aucune sorte sur ses caractéristiques.

En contrepartie, la simulation ne résout pas directement un problème comme le ferait une

méthode d’optimisation. Elle montre simplement comment se comporte le système modélisé

quand on lui apporte telle ou telle solution. Ainsi, par exemple, la simulation ne donnera pas le

niveau minimal des stocks de sécurité pour éviter toute rupture, mais déterminera le nombre de

3

ruptures quand on fixe les stocks de sécurité à tel ou tel niveau. La simulation n’est donc pas un

outil d’optimisation à proprement parler mais d’aide à la décision.

Une autre caractéristique essentielle des modèles de simulation concerne leur nature dynamique.

Le comportement du système modélisé va être représenté par son évolution au cours du temps.

Cette approche dynamique favorise également une meilleure connaissance du système. Pour le

modéliser, il faut décrire ce qui se passe chaque fois qu’un évènement se produit. Cette

description établit fréquemment une différence entre ce que l’on imagine, et ce qui est

effectivement réalisé. Mettre en lumière ces écarts, c’est déjà avancer vers une solution du

problème.

Lors de la définition d’un nouvel investissement, l’utilisation de la simulation de flux permet de

dimensionner l’investissement au plus juste (en termes de performance), de définir le meilleur

timing de celui-ci (dans le cas d’une montée en régime progressive), de prévoir le comportement

du système en exploitation et d’anticiper les problèmes futurs qui nuiront à la rentabilité. D’autre

part, lors d’études d’amélioration de la gestion des flux d’un système de production existant, la

simulation de flux est un outil support important pour valider de nouvelles approches, paramétrer

un système de pilotage, etc.

L’activité type d’une ingénierie, c’est avant tout de définir un investissement au plus juste. Les

ingénieries ont une forte tendance à reconduire le passé avec des homothéties et des analogies

plus ou moins risquées. A chaque extrapolation, des coefficients de sécurité sont pris pour

diminuer les risques, ce qui entraîne un surdimensionnement quasi systématique. Reconduire

systématiquement le passé à échelle de plus en plus grande génère inévitablement des surcoûts

d’investissement. Or, la modélisation et la simulation de flux sont des outils puissants de pré

étude pour sortir de cette spirale. L’enjeu peut être du type « assurance » surtout quand des

modifications importantes sont tentées par rapport à un projet passé.

1.4 Le logiciel Extend

Extend, développé par Imagine That! est une plate-forme de simulation pour l'étude du

comportement de systèmes complexes.

Le logiciel s'applique en productique, en logistique et en organisation d'entreprises (tensions des

flux, dimensionnements d'investissements, en-cours, implantations, tailles de lots, etc.), ainsi que

pour les études de dynamique des systèmes.

Comme dans la plupart des logiciels de simulation actuels, les systèmes étudiés sont représentés

graphiquement grâce à des bibliothèques standards ou spécifiques à un domaine. Ainsi on

4

construit un modèle à partir de blocs représentant des fonctionnalités assez simples comme : une

file d’attente, un délai, une fusion de plusieurs entités, une vanne,… qu’on relie afin de

reconstruire la logique de fonctionnement du système étudié. Un ensemble de fonctions comme

par exemple les blocs hiérarchiques, qui regroupent un ensemble de blocs en une sorte de sous

modèle, permettent d’organiser et de rendre plus lisible le modèle ainsi construit.

MODL, le langage de développement intégré permet de créer facilement des blocs personnalisés

pour étendre les possibilités de l'environnement mais aussi de créer les objets spécifiques à un

secteur d'activité.

Des modules d’extensions étendent les fonctionnalités d’Extend. On retrouve ici notamment SDI

Industry, développé par Simulation Dynamics, qui permet de modéliser facilement des procédés

continus et de relier des processus discrets à ces derniers. De plus, ce module intègre un système

de base de données qui facilite la gestion des données au sein des modèles. Proof Animation, par

Wolverine Software Corp., donne accès à des animations perfectionnées des modèles Extend et

Stat:Fit, par Geer Mountain Corporation, facilite l'analyse de distributions aléatoires.

1.5 1Point2 et Imagine That Inc.

1Point2 et Imagine That! collaborent ensemble depuis leur création. Ce partenariat de longue

durée explique les liens étroits qui les unissent : il ne s’agit plus simplement d’une relation client

fournisseur mais d’une relation privilégiée de mutuelle confiance et assistance.

Actuellement, 1Point2 réalise la traduction d’Extend pour la version française et participe

activement aux programmes de tests des nouvelles versions. En contrepartie, la société possède le

droit de distribution exclusif du logiciel Extend pour l’Europe du Sud et mondialement en ce qui

concerne la version française. Ce point est scrupuleusement respecté et Imagine That! réoriente

régulièrement un client vers 1Point2.

Des chargés d’études d’1Point2 développent également, d’une façon ponctuelle, des parties du

logiciel Extend pour le compte d’Imagine That!.

C’est dans ce cadre que les tests de la V7 doivent être vus. Ils ont étés faits au sein d’1Point2,

pour aider leur partenaire Imagine That! à développer la nouvelle version.

5

1.6 Les phases du développement d’un nouveau logiciel

Version Alpha

Début 2005

Au niveau de l'Alpha, le nombre de clients auxquels on soumet la version est très restreint. On

soumet une Alpha même si le produit ne fonctionne pas encore et que des concepts n'en sont

encore qu'à une phase de développement. Les utilisateurs donnent leur opinion sur le produit,

donnent des idées de leurs besoins spécifiques. Le fonctionnement des blocs peut être

complètement modifié. Le développement n'étant pas complètement abouti, il est possible de

changer beaucoup de concepts, d'en supprimer ou d'en rajouter.

Version Beta

Mai 2006

La liste des Beta Testeurs est presque 10 fois plus étendue que celle des Alpha testeurs. Le

produit est sensé être proche de ce qu'il va être lors de sa commercialisation, le fonctionnement

des blocs déjà implémenté ne va pas changer. Le temps passé par les équipes de développeurs est

principalement consacré au débogage et à la documentation. Les testeurs sont sensés pouvoir

déjà construire des modèles qui pourront être utilises lors de la commercialisation du logiciel. La

version Beta est utilisée pour commercialiser une mise à jour robuste de Extend, l'avantage étant

que beaucoup d'utilisateurs différents on pu utiliser le nouveau produit dans différents contextes.

Commercialisation V7

Fin 2006

C'est la première fois que Imagine That! a un cycle Alpha. La Version 7 est la mise à jour la plus

étendue en termes de nouvelles fonctionnalités jamais réalisée par eux. En plus, la liste de Beta

testeurs est beaucoup plus importante que dans les précédentes mises à jour.

C’est évident qu’il n’y a pas encore de textes d’aide dans les versions Alpha et Beta. Les testeurs

doivent par conséquence se baser sur leur connaissance de la version précédente et la logique des

dialogues des blocs. Comme le fonctionnement des blocs a été modifié totalement entre les

versions, tous les modèles faits en Alpha ne peuvent plus être utilisés en Beta. Par contre, il y a

une compatibilité ascendante par rapport aux modèles dans la V6.

6

2 Flux discret

2.1 Introduction

La simulation se divise en deux mondes très distincts, celui des simulations discrètes et celui des

simulations continues. Les termes de discret et de continu s’appliquent en fait à la nature des flux

examinés, et par extension à la nature des modèles.

Ces notions sont très importantes à comprendre, car il s’agit vraiment d’approches différentes,

avec une gestion du temps qui est différente et aussi des familles d’outils informatiques distinctes.

Il importe de bien se repérer par rapport à ces deux notions, car traiter un cas discret avec une

approche ou un logiciel continu (ou vice versa) peut conduire à une grande inefficacité, voire à de

lourdes erreurs.

Dans des simulations discrètes, les flux essentiels que l’on examine sont composés d’éléments

isolables que l’on peut dénombrer et identifier individuellement. Ces éléments sont couramment

appelés « entités » et pourront être indifféremment toute forme de matière ou d’information

appréhendée individuellement dans le système. Ce qui arrive à ce flux se considère en termes

d’événements correspondant à un changement dans l’état du système, ce que l’on pourrait appeler

des actions.

Dans les simulations continues, il n’est pas possible d’isoler quoi que ce soit dans le flux étudié –

parce qu’il est continu ! Ce qui arrive à ce flux a pu être exprimé sous une forme mathématique

(équations différentielles), et se considère en termes de taux de modification dans le temps.

Dans un modèle discret, on compte ; dans un modèle continu, on calcule.

Figure 1: Le flux discret et continu

Par contre, la différence n’est pas toujours si claire que ça. Premièrement, du flux continu peut

être simulé en utilisant du temps discret, c'est-à-dire, il y a un bloc exécutif qui crée des

événements. Deuxièmement, la différence entre le flux discret et le flux continu souvent n’est pas

évident non plus.

7

Par exemple, un centre de tri postal traite des lettres individuellement, mais la quantité est d’une

telle hauteur qu’il vaut mieux de l’analyser de manière continu. Le « découpage » du flux est un

des problèmes récurrents en simulation. Les limites entre continu et discret sont proches et

dépendent du point de vue et de ce que l’on recherche.

Extend peut traiter le flux discret, le flux continu et des combinaisons des deux types.

L’introduction d’Extend dans la formation se fait par le flux discret, parce que c’est plus

compréhensible pour commencer.

2.2 Les modèles

On reprendra la même structure pour décrire tous les modèles. Ils peuvent servir comme fiche

pratique des modèles, que le formateur peut utiliser à côté des présentations en PowerPoint qui

ont été faites.

• Type : exemples ou exercice

• Enoncé

• But : Le but de l’exemple ou l’exercice

• Concepts introduits : Si un nouveau concept est introduit dans le modèle, une petite

description est donnée.

• Blocs introduits : Si un nouveau bloc est introduit dans le modèle, une petite description

est donnée. Ces blocs sont encerclés et énumérés sur les figures. Les mêmes numéros

reviennent dans la description.

• Blocs erronés : Les modèles sont faits dans la version Beta 2. Les erreurs qui ne sont pas

encore résolues, sont mentionnées en bref. Ces blocs sont encadrés en rouge sur les

figures.

• Commentaire

8

2.2.1 Interne A

Figure 2 : Interne A US

Type : Exemple

Enoncé : Des patients se présentent aux urgences d’un hôpital. Il arrive en moyenne un patient

par heure. L’interne de service met environ 0.99 heure/patient pour établir un diagnostic.

Combien de fauteuils prévoir dans la salle d’attente ?

But : Montrer l’utilité de simulation.

Concepts introduits :

1. Arrivées aléatoires : les fréquences d’arrivées dans le bloc ‘Create’ sont déterminées à base

d’une distribution Poisson.

2. Délai aléatoire : Le délai des entités dans le bloc ‘Activity’ est spécifié par une distribution

exponentielle.

Blocs introduits :

1. Executive: Ce bloc est le cœur de chaque modèle et doit être placé à gauche de tout autre

bloc du modèle. Il permet de contrôler la durée de la simulation en fonction de l'heure de

fin (celle spécifiée dans le dialogue Paramètres), ou par un nombre d'événements spécifié

dans le dialogue.

2. Create: Fournit les entités d'une simulation discrète à des intervalles de temps donnés. Il y

a deux options : spécifier les fréquences d’arrivées selon une distribution aléatoire ou un

calendrier d’arrivées. C’est un bloc « pousseur ». Ces blocs poussent leur entité quelque

soit l’état du bloc aval.

1

2 3 4 5

9

3. Activity: Peut contenir plusieurs entités et les transmet en fonction de leur heure d'arrivée

et du délai subi. L'entité arrivée le plus tôt avec le plus petit délai est transmise la

première. Le délai propre à chaque entité peut être déterminé de plusieurs manières.

4. Queue: File d'attente. Plusieurs types sont possibles : le type Premier-entré-premier-sorti

(first-in-first-out = FIFO) est utilisé le plus souvent. Puis il y a les options Dernier-entré-

dernier-sorti (last-in-first-out = LIFO) et tri par valeur attribut ou par priorité. La

longueur maximale détermine la capacité de la file et peut être indiquée dans le dialogue.

Il y a un onglet avec les résultats, qui fournit entre autres la longueur moyenne de la file,

son taux d'utilisation et le temps d'attente moyen des entités.

5. Exit: Fait sortir des entités de la simulation.

Commentaire : Les stagiaires doivent répondre la question avant la simulation. Avec une

distribution Poisson en entrée et exponentielle en traitement, le nombre moyen de patients en

attente est 48, avec un maximum de 102 pour des simulations de 5000 heures !

2.2.2 Interne B

Figure 3 : Interne B US

Type : Exemple

Enoncé : Des patients se présentent aux urgences d’un hôpital. Il arrive en moyenne un patient

par heure. L’interne de service met environ 0.99 heure/patient pour établir un diagnostic.

Combien de fauteuils prévoir dans la salle d’attente ?

But : L’exemple de l’interne est étendu pour introduire les concepts de base d’Extend.

1

10


1. Clone tool : Par défaut, les éléments de dialogue figurent dans les dialogues. Mais dans

des gros modèles, devoir passer par des dialogues pour vos paramétrages peut devenir un

inconvénient. Vous pouvez faire glisser un clone (une copie) d'un élément de dialogue

dans la fenêtre du modèle, dans un journal de bord ou dans la fenêtre d'un bloc

hiérarchique.

2. Différents fenêtres : Dans un modèle, il y a plusieurs fenêtres. L’espace de travail est le

plus important, mais la bibliothèque et le journal de bord sont aussi essentiels. Chaque

modèle possède un journal de bord utilisable pour contrôler les paramètres du modèle,

afficher des résultats et documenter le modèle. Ce journal vous donne beaucoup de

souplesse si vous l'utilisez avec des éléments clonés. Vous pouvez réunir dans le journal

les clones des paramètres auxquels vous voulez avoir un accès facile, sans qu'ils ne

surchargent la fenêtre du modèle. Vous pouvez utiliser un journal pour des valeurs saisies

(en entrée) ou observées (en sortie). Autrement dit, pour modifier dynamiquement des

paramètres, ou pour réunir des résultats d'une manière pratique à observer et à imprimer.

Cela permet aussi de faire une interface pour les utilisateurs d’un modèle qui ne sont pas

très habitués avec les modèles.

Figure 4 : Journal de bord

3. Composants d'un modèle

4. Composants d'un bloc

5. Suivre le contenu d'un stock/exit : Dans le traceur, on peut suivre le contenu de la file

d’attente, qui représente une salle d’attente.

11

Figure 5 : Traceur

Blocs introduits :

1. Plotter, Discrete Event : Ce traceur s'emploie pour tracer des files d'attente, des valeurs

d'attributs, des comptages, etc. Pour chaque entrée, la table en dessous du graphique note

la valeur et le temps où cette valeur a été émise.

2.2.3 Aléas de production

Figure 6 : Aleas de production US

Type : Exemple

Enoncé : Deux postes en ligne reçoivent des pièces d’un stock infini. Ils effectuent la même

opération de durée moyenne 60 secondes, mais avec des fluctuations.

But : Equilibrer des opérations de durées aléatoires.


Stock infini

1

12

Blocs introduits :

1. Resource Item : Ce bloc contient et fournit des entités (automobiles, commandes,

opérateurs, etc.) du modèle. Il peut intervenir dans des systèmes ouverts ou fermés.

Contrairement au bloc ‘Create’, ce bloc n'est pas "Pousseur". Ce bloc est comparable à

une File. Les entités peuvent être extraites, tant qu'elles sont disponibles. On peut

spécifier la quantité initiale. Selon les besoins de la simulation, on peut choisir un stock

fini ou infini.

2.2.4 Génération d’entités

Figure 7 : Generation d'entites US

Type : Exercice

Enoncé : 2 postes en ligne reçoivent 1 pièce chaque minute. Ils effectuent la même opération de

durée fixe 60 secondes.

But : Dimensionner le stock inter-postes.


1. Arrivées programmées : Spécifier un calendrier d’arrivées dans le bloc ‘Create’. Prévoir un

stockage après, comme le bloc est pousseur.

2. Délai fixe : Les activités ont une durée fixe.

Commentaire : Les stagiaires peuvent partir de l’exemple ‘aléas de production US’. Puisque c’est

le premier exercice, il n’y a pas beaucoup de modifications à faire.

13

2.2.5 Pannes

Figure 8 : Pannes US

Type : Exercice

Enoncé : 2 postes en ligne reçoivent des pièces selon une loi exponentielle avec un temps moyen

de 1 minute entre les arrivées. Ils effectuent la même opération de durée fixe 60 secondes. Les

machines tombent en panne en moyenne toutes les 45 minutes, selon une loi exponentielle. Il

faut de 4 à 6 minutes (loi triangulaire, 5 minutes plus probable) pour réparer.

But : Dimensionner le stock inter-postes.


1. Suivre les pannes d’une activité : Le bloc ‘Activity’ a 8 connecteurs sortie valeur. Le

connecteur D (Down) peut être utilisé pour visualiser les pannes.

2. Décaler des valeurs pour les afficher dans traceur : Quand on veut afficher plusieurs

valeurs dans le traceur qui sont dans le même ordre de hauteur, il vaut mieux les décaler

en avant. On peut faire ça facilement avec le bloc ‘Constant’.

3. Blocage de l'aléatoire : Les valeurs aléatoires sont calculées par un générateur aléatoire

interne à Extend qui utilise un nombre appelé base aléatoire afin de produire aussi bien

des séquences aléatoires indépendantes que des séquences aléatoires reproductibles.

Extend affecte une base aléatoire différente à chacun des blocs aléatoires d'un modèle.

Dans le dialogue Paramètres de la simulation, c’est possible de donner la même base

aléatoire à tous les blocs du modèle, bloquant ainsi le générateur de nombres aléatoires

1

2

14

sur une séquence particulière, ce qui permet de voir l'effet d'hypothèses de simulation qui

ne seront pas perturbées par des variations aléatoires.

4. Générer des pannes aléatoires

Blocs introduits :

1. Shutdown : Ce bloc permet de générer des pannes aléatoires. On peut spécifier le TBF

(Time Between Failures) et le TTR (Time To Repair) de manière constante ou aléatoire

(selon une distribution). En plus, c’est possible de combiner les pannes avec la

maintenance prévue et l’usure.

2. Constant : Génère une valeur constante à chaque étape. Si l'entrée est liée, sa valeur est

ajoutée à la constante du dialogue. Ce bloc s'emploie typiquement pour donner des

valeurs initiales à d'autres blocs ou pour décaler des valeurs.

Commentaire : Les stagiaires peuvent partir de l’exemple ‘génération de production US’.

Figure 9 : Traceur

15

2.2.6 Exercice 1

Figure 10 : Exercice 1 US

Type : Exercice

Enoncé : On cherche à définir la capacité de production d’un îlot de 3 machines de

conditionnement et à déterminer les quantités de stockage nécessaires entre chaque machine.

Les pièces entrent dans la machine 1 (durée=17mn). Les pièces sont ensuite dirigées en priorité

sur la machine 2. Si la capacité de stockage limite de 5 est atteinte devant cette machine, les pièces

sont dirigées sur la machine 3.

Les machines 2 et 3 ont le même temps de traitement (plus probable=23mn, min=20mn,

max=25mn). Elles doivent subir une maintenance de 90 minutes au moins toutes les 1000

minutes et au plus toutes les 1300 minutes. Option : faire en sorte que les maintenances des deux

machines soient décalées (quel en est l’avantage ?)

Lancer une simulation sur 7200 minutes (1 semaine en 3*8, 5 jours sur 7).

But : Déterminer les indicateurs pertinents et en tirer les conclusions nécessaires.


1. Décaler des maintenances prévues : Comme il y a des maintenances prévues sur 2

machines, c’est logique qu’elles ne soient pas faites en même temps. Pour cette raison, on

1

2

16

impose une première maintenance sur la machine 2 après 500 minutes. Avec le bloc

‘Lookup Table’ on émet la valeur ‘1’ entre 500 et 590 minutes au connecteur d’entrée

‘sched’ (scheduled). On choisit l’option dans le bloc Shutdown que la maintenance prévue

(‘scheduled’) remets le TBF à zéro.

2. Sélectionner sortie par priorité explicite : la sortie à laquelle l’entité est envoyée est choisie

selon une préférence fixe, saisie par l’utilisateur. Dans ce cas-ci, la sortie en haut est

prioritaire.

Blocs introduits :

1. Select Item Out : Aiguille les entités selon une certaine logique. L'entité présente en

l'entrée est transmise à la sortie sélectionnée. Le dialogue permet de modifier la sortie

séquentiellement, aléatoirement, selon l’attribut de l’entité (voir prochain chapitre) ou

d'effectuer un choix de sortie d'après la valeur du connecteur Select.

2. Lookup Table : Génère la valeur de sortie en fonction du temps ou d’une entrée, selon

une table de conversion, remplie par l’utilisateur dans le dialogue.

Blocs erronés :

‘Ressource Item’ (fait bloquer la simulation après avoir sorti quelques entités) et ‘Shutdown’

(maintenance prévue ne marche pas bien)

Figure 11 : Traceur exercice 1 US

Commentaire : On peut voir sur le traceur que la première maintenance sur machine 2 est

générée correctement, mais que les suivantes ne sont pas décalées par rapport à la machine 3 et

peuvent arriver au même moment.

17

3 Attributs

3.1 Introduction

Les attributs jouent un rôle important dans les simulations discrètes. Parce qu’elles sont

individualisables, les entités peuvent être caractérisées, comme par une fiche signalétique. Cette

carte d’identité de l’entité est souvent rendue au moyen d’attributs pouvant prendre des valeurs

ou des chaînes des caractères. Ce sont des caractéristiques qu'une entité transporte avec elle lors

de sa progression dans le modèle.

Les attributs valeur peuvent être exploités de manière numérique (valeur de l’attribut) ou de

manière logique (zéro ou un, l’entité possède l’attribut ou pas). Par exemple, les attributs valeur

peuvent être utilisés en direct pour spécifier le temps d’opération dans une machine.

Pour les attributs chaîne de caractères, on doit spécifier toutes les chaînes possible dans le bloc

‘Executive’. Par exemple, ils peuvent être employés pour diriger les entités.

3.2 Modèles

3.2.1 Rodéo

Figure 12 : Rodéo US

Type : Exemple

Enoncé : Exemple du rodéo mécanique. Il y a un rodéo mécanique sur la kermesse. Les gens

restent en selle pendant un temps variable. Ceux qui réussirent à rester sur le rodéo pendant une

1 2

3

18

minute, gagnent une bouteille de champagne et partent. Trois quarts des autres s’arrêtent et

l’autre quart réessaie. Ils doivent refaire la queue pour un passage.

But : Montrer l’utilité d’attributs


1. Donner une valeur aléatoire à un attribut : 10% des gens peuvent rester 15 secondes en

selle, 35% pendant 30 secondes, 45% 45 secondes et enfin 10% réussissent à rester une

minute. Ces temps sont enregistrés dans un attribut valeur. Le bloc ‘Random Number’

génère les valeurs selon les probabilités susmentionnées. Ces valeurs sont « attachées »

aux entités dans le bloc Set. Ca veut dire que tous les entités reçoivent un attribut ‘temps’

avec une valeur. C’est comme si les gens doivent tirer une carte avant de monter sur le

rodéo et que la carte leur dit le temps qu’ils resteront en selle.

2. Délai dépendant d'un attribut : Le délai du bloc ‘Activity’ est déterminé par l’attribut

‘temps’ de l’entité qui est entré.

3. Sélectionner sortie dépendant d'un attribut : L’attribut ‘temps’ détermine aussi quelle

sortie les entités doivent prendre après le premier bloc ‘Select Item Out’.

4. Sélectionner sortie de manière aléatoire : La sortie dans le deuxième bloc ‘Select Item

Out’ est choisi de manière aléatoire : 75% des entités prennent la sortie en haute.

5. Sélectionner entrée de manière séquentielle : Les entités des deux flux sont rejointes dans

le bloc ‘Select Item In’ de manière séquentielle.

Blocs introduits :

1. Random Number : Génère des nombres entiers ou réels en fonction de la distribution

sélectionnée.

2. Select Item In : Choisit d'envoyer une entrée en sortie selon une certaine logique. L'entité

présente sur l'entrée sélectionnée est transmise à la sortie. Le dialogue permet de choisir 4

options : sélectionner l’entrée selon priorité explicite, connecteur sélection, de manière

aléatoire ou de manière séquentielle.

3. Set : Donne un au plusieurs attributs aux entités qui traversent le bloc. Les attributs

peuvent s'ajouter ou remplacer les attributs existants de l'entité.

Blocs erronés :

‘Select Item In’ (Option de sélectionner la sortie dépendant d’un attribut ne marche pas toujours

comme il faut)

19

3.2.2 Equation Item

Figure 13 : Equation Item US

Type : Exemple

Enoncé : Une activité a un délai qui dépend de la longueur de la file d’attente en amont :

33

LongueurTemps −=

La machine accélère donc quand la file d’attente devient plus longue. Par contre, son temps

minimal est une minute.


Donner une valeur prédéterminée à un attribut : La valeur calculée dans le bloc ‘Equation Item’

est stockée dans l’attribut ‘temps’

Blocs introduits :

1. Equation Item : Calcule une équation au passage d'une entité. Les entrées de l'équation

sont des attributs de l'entité, sa valeur ou sa priorité, des valeurs lues sur les connecteurs

d'entrée, … Le résultat de l'équation peut être affecté à un attribut ou à un connecteur de

sortie. Pour saisir l’équation, on peut utiliser tous les fonctions du langage MODL. En

fait, on peut y écrire un petit programme. Dans notre exemple, l’équation suivant est

utilisé :

Temps=Max2(1,3-Longueur/3);

Resultat=Temps;

1

2

20

2. History : Affiche des informations sur les entités qui parcourent le bloc. La première

colonne du tableau du dialogue donne l'heure d'arrivée des entités dans le bloc. Les autres

colonnes indiquent les valeurs des attributs dont les noms sont spécifiés.

Figure 14 : Traceur

3.2.3 Peinture

Figure 15 : Peinture US

Type : Exercice

Enoncé : Dans un poste de peinture, la durée de traitement dépend du type de pièce. Chaque

heure, un lot de 12 pièces arrive: 4 entités Alpha (durée 8 minutes), 5 Beta (12 minutes) et 3

Gamma (15 minutes). Les pièces sont stockées par type

21

But : Faire l’exercice en utilisant des attributs valeur et chaîne.

3.2.4 Retouche A

Figure 16 : Retouche A US

Type : Exercice

Enoncé : On reprend l’exercice ‘Peinture US.mox’. En fin de traitement, 1 pièce sur 8 doit être

retouchée et repasse sur le poste pour une durée deux fois plus courte. Les pièces qui passent en

retouche sont prioritaires par rapport aux autres pièces. Une pièce mal peinte étant déjà passée en

retouche doit être rebutée.


1. File d'attente triée selon attribut : Une des options d’une file d’attente est de trier les

entités en fonction de la valeur d’un attribut.

2. Changer la valeur d'un attribut : Les attributs des entités peuvent changer lors de la

progression dans le modèle. Dans ce modèle, l’attribut ‘retouche’ est changé dans le bloc

‘Set’ dans le boucle pour pouvoir trier les entités prioritaires dans la file d’attente. En plus,

la valeur de l’attribut ‘temps’ est divisé par deux dans le bloc ‘Equation Item’ après

l’activité.

Blocs erronés : ‘Queue’ (les entités ne sont pas triées correctement)

22

3.2.5 Retouche B

Figure 17 : Retouche B US

Type : Exercice

Enoncé : Même énoncé que ‘Retouche A US’


1. Priorité : En fait, la priorité d’une entité est un attribut de plus. C’est une propriété qu’une

entité possède et qui lui permet d’avoir la priorité dans certaines situations. L’entité avec

la plus petite valeur a la priorité. Ici, la priorité est utilisé pour trier les entités dans la file

d’attente et pour les diriger dans le boucle ou à la sortie ‘rebut’.

Les entités qui entrent le modèle ont une priorité de 2. Les entités retouchées reçoivent

une priorité de 1.

2. Délai dépendant du connecteur D : Le délai de l’activité est calculé dans le bloc ‘Equation

Item’, dépendant de la priorité et de l’attribut ‘Traitement’ :

If (Prio==1)

Resultat=Traitement/2 ;

Else Resultat=Traitement ;

Le résultat est transféré vers le bloc ‘Activity’ via des connecteurs de valeur.

3. Sélectionner sortie par connecteur sélection : Une pièce mal peinte étant déjà passée en

retouche doit être dirigée vers la sortie ‘rebut’. Comme les entités déjà retouchées ont une

priorité de 1 et les autres de 2, on peut utiliser cette propriété pour faire cette décision.

4. File d'attente triée selon priorité : Les pièces qui passent en retouche doivent être

prioritaires par rapport aux autres pièces. On peut réaliser ça on utilisant la priorité.

1

23

Blocs introduits :

1. Get : Affiche et/ou efface les attributs, les valeurs ou les priorités d'entités, puis passe

l'entité vers l'aval. Ce bloc n’est plus beaucoup utilisé, parce que dans la V7, presque tous

les blocs peuvent exploiter les attributs, les valeurs et les priorités eux-mêmes.

Commentaire : Pour l’exercice ‘Retouche’, deux solutions sont prévues. La première est la plus

logique, mais la deuxième est très utile parce qu’elle utilise beaucoup de nouveaux concepts et un

nouveau bloc.

Naturellement, les mêmes résultats sont obtenus par les deux solutions.

24

4 Flux continu

4.1 Introduction

Les modèles dans ce chapitre sont des modèles de flux continu, mais la gestion du temps se passe

de manière discrète, c'est-à-dire en utilisant des événements. C’est le bloc ‘Executive’ (à gauche en

haut dans tous les modèles) qui gère les événements.

4.2 Modèles

4.2.1 Discret et continu

Figure 18 : Discret et continu US

Type : Exemple

1 2

3

25

Enoncé : Un processus requiert trois actions :

1. 5 minutes par entité ou un débit de 0.2 entités par minute

2. 4 minutes par entité ou un débit de 0.25 entités par minute

3. 5.56 minutes par entité ou un débit de 0.18 entités par minute

But : Introduire le flux continu et montrer les différences avec le flux discret.


1. Flux continu : Le raisonnement se fait en termes de débit et non plus selon des temps de

traitement.

2. Stock fini : L’architecture discrète ainsi que l’architecture continue commencent par un

stock de 1000 entités.

3. Suivre le contenu d’un stock continu : On suit le contenu de la sortie discrète et du stock

continu. Comme les actions ont les mêmes propriétés dans les deux architectures, le

temps pour traiter les 1000 entités est le même.

Figure 19 : Traceur

Blocs introduits :

1. Tank : Représente un stock continu (par exemple une cuve ou un silo) et peut être utilise

comme:

a. Point de départ pour un système continu (pas de débit entrant, contenu initial fini

ou infini)

b. Point de sortie pour un système continu (pas de débit sortant, contenu initial

zéro)

c. Un stock en milieu du processus

Tous les modèles continus doivent commencer et finir par un bloc ‘Tank’

2. Valve : Représente une contrainte de débit (par exemple une vanne), mais peut aussi être

utilisé comme une activité (par exemple un mélangeur ou un four)

3. Pause Simulation : Ce bloc est utilise pour mettre la simulation en pause après chaque

événement ou après l’événement le plus proche d’un temps spécifié.

26

Blocs erronés : ‘Ressource Item’ (fait bloquer la simulation après avoir sorti quelques entités)

Commentaire :

On peut modéliser du discret par du continu ou du continu par du discret. C’est un choix pas

forcément trivial.

On a vu que le temps simulé est le même. Par contre, le temps de calcul (temps de la simulation)

est beaucoup moins important à cause du nombre réduit d’événements : quelques secondes pour

le flux discret, quelques dizaines d’un seconde pour le flux continu.

4.2.2 Variation débit

Figure 20 : Variation debit US

Type : Exemple

But : Montrer les 4 statuts différents du bloc ‘Valve’ : satisfait, partiellement satisfait, débit zéro

et bloqué ou affamé.


1. Vanne avec un débit variable : Via le connecteur r (rate) du bloc ‘Valve’, on peut régler le

débit de la vanne. Les valeurs sont générées par le bloc ‘Lookup Table’. Le débit variable

a des conséquences pour les deux autres vannes, qui ont un débit maximal fixe. Selon le

débit de la vanne au milieu, leur statut change.

27

2. Suivre un débit : C’est un peut contradictoire, mais on peut suivre un débit au moyen

d’un traceur discret.

4.2.3 Four

Figure 21 : Four US

Type : Exemple

Enoncé : Un four alimente deux silos en continu, avec un débit de sortie variable suivant une loi

triangulaire. Les deux silos alimentent eux-mêmes un atelier en aval, avec un débit fixe. L’atelier a

besoin d’être alimenté en continu. On va prélever la matière dans le silo le plus rempli.

But : Introduction des blocs ‘Merge’ et ‘Diverge’


Sélectionner entrée par sélecteur entrée : Comme dans le bloc ‘Select Item In’, on peut

sélectionner l’entrée au moyen d’un connecteur. Le silo le plus rempli est déterminé par le bloc

‘Max & Min’, qui envoie le numéro du silo au connecteur ‘sélecteur entrée’ du bloc ‘Merge’.

Blocs introduits :

1. Diverge : La matière continue se dissocie par les blocs ‘Diverge’. Dans la dernière version,

il y avait 6 modes pour choisir la ou les sorties. D’autres modes peuvent être ajoutés

encore :

a. Priority of inputs : spécifie une source prioritaire si le débit sortant ne permet pas

de tout absorber.

b. Proportional : spécifie les pourcentages, indépendant de la relation entre offre et

demande.

1 2

3

28

c. Distributional : essaie d’abord de maximiser le débit, puis d’être le plus proche

possible des pourcentages spécifiés dans le dialogue.

d. Assembly : débit en sortie cadencé au plus lent des 2 débits entrants.

e. Select an input : choix d’une source avec le connecteur select.

f. Neutral : assure seulement que le somme des débits d’entrée égale le débit de

sortie

2. Merge : matière continue s’associe par les blocs ‘Merge’

3. Max & Min : Détermine le maximum et le minimum parmi plusieurs valeurs en entrée. Le

dialogue affiche ces valeurs et le numéro du connecteur d'où elles proviennent. Des

connecteurs émettent ces mêmes informations.

Blocs erronés : Diverge (option sélectionner sortie de manière proportionnelle ne marche pas) et

Merge (option sélectionner entrée par sélecteur entrée ne marche pas)

4.2.4 Four-mélangeur

Figure 22 : Four-melangeur US

Type : Exercice

1 2

29

Enoncé : Deux stocks infinis alimentent un four (débit suivant une loi triangulaire : 1;5;3). Après

le four, les ingrédients sont stockés séparément dans 2 silos différents. Le four produit ingrédient

1 pendant 30’, puis ingrédient 2 pendant 20’. Avant un changement d’ingrédient, un nettoyage du

four de 5’ est prévu.

Après les silos, les ingrédients sont mélangés selon la recette suivante: 3/5 d’ingrédient 1 et 2/5

d’ingrédient 2. Le débit est fixe : 3 l/min.

Le mélangeur a besoin d’être alimenté en continu, parce qu’il prend beaucoup de courant pour

redémarrer. Pour cette raison, il ralenti quand un des silos atteint une limite inférieure: débit 1

l/min.

But :

1. Trouver les indicateurs du bon fonctionnement du modèle.

2. Donner une taille optimale pour les silos.

3. Trouver la limite inférieure pour ralentir le mélangeur.


(Dés)activer une valeur aléatoire en la multipliant par un binaire : Pour imposer les nettoyages, la

valeur venant du bloc ‘Random Number’ est multipliée par un binaire. Ce binaire est zéro dans

les périodes de nettoyage et un ailleurs.

Blocs introduits :

1. Equation : Sort le résultat d'une équation entrée dans le dialogue.

2. Math : Calcule le résultat d’une opération avec les valeurs des connecteurs. L’opération

est sélectionnée dans le dialogue. Il y a plusieurs catégories :

a. Mathématique

b. Financial

c. Goniométrique

d. Logique

Deux opérations sont utilisées dans notre modèle : ‘Not’ (logique) et multiplication

(mathématique)

Blocs erronés : Les blocs ‘Merge’ et ‘Diverge’ (les options sélectionner sortie/entrée par

connecteur sélecteur et de manière proportionnelle, ne marchent pas)

Commentaire : A cause des blocs erronés, il n’était pas encore possible de déterminer les valeurs

optimales des paramètres.

30

4.2.5 Batch Flux Mixtes A

Figure 23 : Batch flux mixtes A US

Type : Exercice

Enoncé : On constitue des batch de 6 tonnes qui vont subir une opération d’évaporation. Une

étude à montré que les Batch avaient un taux d’humidité variable :

Humidité Probabilité

25% 20%

20% 50%

15% 20%

10% 10%

Le temps de l’évaporation (base 5h si 100% d’évaporation) et la quantité de matière sortant de

l’évaporateur dépendent de cette proportion. L’opération d’évaporation ne commence qu’à la fin

du chargement (débit pour charger = 20t/h).

But : Assurer la traçabilité des batch passés en évaporation : numéro de batch, humidité et heure

de sortie de l’évaporateur.


1. Enumérer les entités : Les batch sont comptés dans le bloc ‘Information’. Leur numéro

de batch est envoyé au bloc ‘Set’, où il est affecté à l’attribut ‘Numéro’.

1 2

31

2. Le bloc 'Interchange' en boucle ouvert : En boucle ouvert, le bloc ‘Interchange’ est

capable de générer et « faire disparaître » des entités. Dans ce cas-ci, c’est nécessaire, parce

qu’il n’y a pas d’entités en réalité.

Blocs introduits :

1. Information : Bloc qui peut fournir de l’information sur les entités qui passent dans le

bloc. Il les compte et peut calculer le temps entre deux passages, …

2. Interchange : Agit comme un réservoir interface aux entités. Selon les choix dans le

dialogue, une entité entrant peut être le réservoir (indiquant le contenu et la capacité du

réservoir tandis que l'entité est dans le bloc) ou une entité entrant peut être séparé du

réservoir, déposant une partie ou tout son contenu dans le réservoir quand il arrive, et/ou

en enlevant une partie ou tout le contenu du réservoir quand il part.

Le réservoir agit comme source, stockage intermédiaire ou sortie. Le contenu est reçu

d’un autre bloc ou il y a une quantité initiale.

Blocs erronés : Interchange (pas encore capable de générer les entités)

Commentaire : Pour traiter des batch de matière continue séparément, il vaut mieux les

convertir en flux discret. Par conséquence, le modèle ne ressemble pas du tout à la réalité, mais il

fait exactement ce qu’il doit faire.

32

4.2.6 Batch flux mixtes B

Figure 24 : Batch flux mixtes B US

Type : Exercice

Enoncé : Même énoncé que pour l’exercice ‘Batch flux mixtes A US’, sauf qu’en sortie de

l’évaporateur, on rempli des wagonnets de 4 tonnes, avec un débit de 6 tonnes/h. Les wagonnets

sont mis sur une chaîne, qui traverse un four en 3 heures. Il peut y avoir 10 wagonnets au même

temps dans le four. Puis les wagonnets sont vidés dans un silo à un débit de 6 tonnes/h. Ils

retournent au point de chargement via une autre chaîne. Ca prend 30 minutes et il y a 15 places

pour des wagonnets.

But : Combien de wagonnets doit on prévoir ?


1. Activités multiples : Le bloc ‘Activity’ peut contenir plusieurs entités et les transmet en

fonction de leur heure d'arrivée et du délai subi. L'entité arrivée le plus tôt avec le plus

petit délai est transmise la première.

2. Le bloc 'Interchange' en boucle fermé : En boucle fermé, les entités peuvent être

remplies, vidées et puis réutilisées.

33

Blocs erronés : ‘Interchange’ (pas encore capable de générer les entités) et ‘Activity’ (problèmes

avec les indices)

Commentaire : En jouant avec le paramètre ‘nombre de wagonnets’, l’utilisation des wagonnets

et le nombre de wagonnets traités, change. Les paramètres sont clonés sur la fenêtre principale.

Pour des modèles plus lourds, il faut les mettre dans le journal de bord, afin de ne pas retarder les

simulations.

34

5 Base de données

5.1 Introduction

Dans Extend, il y a une base de données qui est graphique, complètement intégrée et accessible

de tous les blocs. C’est un système complet pour créer, visualiser et gérer toutes les données du

modèle, pour configurer des tableaux et des expériences, de nouveaux formats dans les attributs,

avec les blocs appropriés pour prendre en compte ces fonctions dans les modèles.

Quelques avantages :

1. Rassembler de manière conviviale les paramètres des modèles en un endroit.

2. Créer une interface pour les non-utilisateurs d’Extend.

3. Faciliter l’exploitation des modèles

4. Accéder rapidement à des données, y compris aléatoires.

5. Simplifier la modélisation des ateliers.

Figure 25 : Exemple d’une base de données dans Extend

35

5.2 Modèles

5.2.1 Barres glacées

Figure 26 : Barres glacees US

Type : Exercice

Enoncé : La production de barres glacées est composée de deux opérations : la production de

glace et le nappage. Trois références sont produites avec chacune un parfum, un nappage et un

poids :

• Saturne (vanille, chocolat au lait, 100g)

• Saturne noir (vanille, chocolat noir, 100g)

• Caraïbes (noix de coco, chocolat au lait, 50g)

Des batch de 500kg sont lancés. A chaque nouveau batch il y a une opération de nettoyage (20

min) Un changement de parfum ou de nappage nécessite 10 minutes de nettoyage extra. Un

changement de poids est suivi d’un réglage de 10 minutes. Le débit de la production de la glace

dépend du parfum (250 Kg/h vanille, 230kg/h noix de coco) Le débit de nappage par contre est

constant: 55 barres/min.

But : Organiser toutes les informations utiles dans une base de données, puis les mettre dans la

base de données intégrée dans Extend et les utiliser dans un modèle.

1 2

3

36

Figure 27 : Base de données de l'exercice Barres glacees


1. Arrivées programmées dans une base de données : La simulation est beaucoup utilisée

pour déterminer le programme de production optimale. Ce programme peut être

facilement exploité dans la base de données intégrée dans Extend. Dans le bloc ‘Create’,

on peut faire un lien entre le modèle la base de données.

2. Dates : Cette option permet de spécifier tous les paramètres de temps dans les blocs en

format de date et heure.

3. Chercher une valeur dans une base de données : Evidemment, il ne suffit pas de

construire une base de données. Il faut utiliser les données dans le modèle.

4. Chercher un indice dans une base de données : Tous les éléments dans une base de

données sont énumérés au moyen d’un indice. Cet indice est beaucoup utilisé pour

comparer des données qui sont en format de chaîne de caractères, parce que ce format

n’est pas idéal pour en faire des opérations.

5. Utiliser la valeur précédente d'un paramètre : Pour comparer des propriétés de deux

entités consécutives, on peut conserver les propriétés dans des variables statiques. Par

contre, quand il n’y pas d’entité dans les blocs ‘Read’, les propriétés de la dernière entité

37

passée restent active. Par conséquence, il est plus facile de chercher les propriétés dans un

bloc où la nouvelle entité n’est pas encore passée.

Blocs introduits :

1. Gate : Passe une entité seulement quand le connecteur ‘demand’ est connecté et certaines

conditions existent à l’entrée. Il y a deux options :

• Porte zone : N'autorise qu'un nombre limité d'entités à accéder simultanément à

une portion donnée du modèle. C’est cette option que l’on utilise ici. Il ne peut y

avoir qu’un batch en production.

• Porte conditionnel : Laisse passer une entité si le connecteur demande est relié et

si certaines conditions sont satisfaites sur ce connecteur (soit la valeur de

demande est vraie (supérieure à 0,5), soit une entité est présente). Selon le type de

connecteur de sortie (entité ou valeur) relié à demande, le bloc passe des entités

simples ou un nombre donné d'entités. Le bloc peut fonctionner à la demande.

On peut le considérer comme une porte qui s'ouvre à la demande, et sur laquelle

la demande peut s'accumuler.

2. Read Item: Ce bloc peut être utilise pour chercher des valeurs dans une base de données.

On peut spécifier la table, le champ et l’enregistrement de manière statique (dans le

dialogue) ou dynamique (dépendant d’un attribut des entités ou de la valeur d’un

connecteur). Le bloc lit et émet une valeur chaque fois qu’une entité passe.

3. Read : Même fonctionnalité que le bloc ‘Read Item’, mais émet une valeur après un

message sur un connecteur.

Blocs erronés : ‘Create’ (lien avec la base de données ne marche pas) et ‘Gate’ (bloque la

simulation)

38

6 Ressources

6.1 Introduction

Une ressource est un stock fini d'éléments, tels que des outils ou de la main d'œuvre, que l'on

utilise en production. Les ressources sont limitées ; on peut spécifier combien d'éléments de telle

ressource sont disponibles à un moment donné. Les ressources peuvent être réutilisées si on le

souhaite. C'est le cas général avec la main d'œuvre, où les personnes sont employées avec d'autres

ressources sur certaines tâches, puis redeviennent disponibles pour d'autres tâches. Il existe deux

manières de modéliser des ressources dans Extend.

Les ressources peuvent être représentées par des entités. Celles-ci peuvent exister en stock, être

générées au hasard ou selon un planning, comme c'est le cas dans une usine réelle.

Les ressources peuvent aussi être représentées par trois blocs associés (‘Resource Pool’, ‘Queue’

et ‘Resource Pool Release’). A la différence du bloc Ressource, les éléments d'un pool ne sont pas

des entités. Il s'agit de variables qui indiquent l'aspect quantitatif d'un facteur limitant. Le bloc

‘Resource Pool’ s'emploie avec le bloc ‘Queue’ pour allouer les éléments du pool à des entités, et

avec le bloc "Resource Pool Release" pour libérer les éléments du pool. Des entités peuvent

attendre pour les éléments d'un pool depuis n'importe quel nombre de blocs ‘Queue’. Le bloc

‘Resource Pool’ détermine comment les éléments sont alloués aux entités : soit l'entité qui est

arrivée la première dans le bloc ‘Queue’, soit l'entité ayant la plus haute priorité (plus faible valeur

numérique de priorité).

Cette méthode a l’avantage de ne requérir aucun lien, et pour cela s’avère spécialement adaptée

lorsqu’une même ressource peut être utilisée à plusieurs endroits. A l’inverse, un même bloc

‘Queue’ peut faire appel à des éléments provenant de différents ‘Resource Pools’, soit parce que

ces éléments sont équivalents et donc interchangeables, soit parce qu’ils sont tous requis

39

6.2 Modèles

6.2.1 Partage de ressources A

Figure 28 : Partage de ressources A US

Type : Exemple

Enoncé : Des pièces arrivent dans un atelier à raison d’une pièce toutes les 5 mn en moyenne.

Les pièces arrivent sur deux postes en parallèle nécessitant des opérateurs ayant la compétence

« conditionner » (délai plus probable de 7 minutes, minimal de 6 minutes et maximal de 8

minutes). Les pièces sont ensuite convoyées (5 minutes), elles arrivent alors sur 4 postes en

parallèle nécessitant des opérateurs ayant la compétence « manutentionner » (délai 12 minutes).

But : Montrer l’utilité des ressources


Sélectionner sortie par priorité implicite : On n’est pas obligé d’utiliser un bloc ‘Select Item Out’

pour déterminer la sortie à laquelle une entité est envoyée. Quand un bloc est lié à plusieurs

sorties, on utilise la priorité implicite. Ainsi, Extend passe les entités au premier poste disponible.

Si plusieurs postes sont disponibles en même temps, l'entité va sur le poste qui a été lié en

premier.

1

2

40

Blocs introduits :

1. Resource Pool : Ce bloc est un "pool" de ressources utilisables dans une simulation. Les

éléments de la ressource peuvent limiter la capacité d'une section d'un modèle. Par

exemple, elles peuvent représenter un nombre de tables limitées dans un restaurant, ou

des outils dans un atelier.

2. Resource Pool Release : Libère des éléments d'un pool de ressource au passage d'une

entité. Il y a deux manières de choisir le pool et le nombre de ressources : de manière

statique (sélectionner les options dans le dialogue) et de manière dynamique (dépendant

d’attributs des entités). Les éléments sont immédiatement libérés vers leur Pool, qui

vérifie aussitôt sa liste d'entités en attente pour essayer de leur allouer les éléments libérés.

Dans le bloc ‘Queue’ on doit spécifier le pool et le nombre de ressources de la même

manière ou on peut aussi le faire via un connecteur.

Blocs erronés : ‘Resource pool release’ (problèmes pour sélectionner le bloc ressource) et

‘Queue’ (problèmes avec l’option ‘resource pool queue’)

6.2.2 Partage de ressources B

Figure 29 : Partage de ressource B US

41

Type : Exercice

Enoncé : On retourne sur le modèle ‘Partage de ressources A US’: sur les 4 derniers postes, on

accepte l’intervention d’opérateurs ayant la compétence «Conditionner» si aucun

manutentionneur n’est disponible.


Utiliser des ressources de plusieurs pools : Pour la dernière activité, on peut utiliser des ressources

d’un deuxième pool s’il n’y en a pas de disponible dans le premier.

Commentaire : Afin de gagner du temps, les stagiaires ne doivent pas commencer de zéro pour

faire cet exercice, mais ils peuvent reprendre l’exemple précédent et faire quelques modifications

subtiles.

6.2.3 Broyeurs

Figure 30 : Broyeurs US

Type : Exercice

1

42

Enoncé : Une unité de broyage traite des batch de 1 tonne de produit. On dispose a priori de 5

broyeurs en parallèle. Chaque broyeur commence par être chargé (1 heure), ce qui requiert un

opérateur. Cette opération est suivie d’une séquence de broyage (3 heures). Puis on fait appel à un

opérateur pour un prélèvement et un tamisage (30 minutes). Une autre séquence de broyage est

alors lancée (durée fonction du résultat du tamisage) On ne tient pas compte du déchargement.

But : On veut faire varier le nombre d’opérateurs et de broyeurs à prévoir pour une future

installation de broyage. Simuler le fonctionnement de cette unité (blocs discrets), sur 500 heures.

Quelle configuration optimise la capacité de production ? Indiquer le taux d’utilisation des

broyeurs et des opérateurs.

Blocs introduits :

1. Display value : Affiche la valeur lue sur le connecteur d'entrée à chaque étape de la

simulation. Sert beaucoup pour la mise au point car vous pouvez voir à tout moment la

valeur d'un connecteur. Utilisé ici pour avoir accès au résultat de l’équation d’une manière

plus claire.

Blocs erronés : ‘Ressource Item’ (fait bloquer la simulation après avoir sorti quelques entités),

‘Gate’ (bloque la simulation), ‘Resource pool release’ (problèmes pour sélectionner le bloc

ressource) et ‘Queue’ (problèmes avec l’option ‘resource pool queue’)

Commentaire : Cette solution est la version la plus logique et la plus simple, mais pas la plus

efficace. Il y pas mal de choses à changer pour faire varier le nombre de broyeurs. Cela prend

donc beaucoup de temps pour trouver l’optimum et il est impossible d’automatiser l’analyse,

comme le nombre de broyeurs n’est pas un paramètre variable

6.2.4 Broyeurs 2

Figure 31 : Broyeurs 2 US

43

Type : Exercice

Enoncé : Même que pour ‘Broyeurs US’

Blocs erronés : Même que pour ‘Broyeurs US’, plus le bloc ‘Activity’ (la simulation se bloque

quand un nombre d’activités infini est choisi)

Commentaire : Cette solution permet d’alléger le modèle par une utilisation judicieuse du

système des ressources et surtout d’ajouter comme paramètre variable le nombre de broyeurs à

utiliser ! C’est un exercice qui est très intéressant car le flux matière n’est pas représenté. Par

conséquent, elle n’est pas évidente au premier vue et les stagiaires ne pensent pas à cette solution.

C’est souvent une erreur de représenter des flux non nécessaires à la compréhension du

problème.

44

7 Les blocs hiérarchiques

7.1 Introduction

Jusqu'à présent, nous avons vu des blocs qui accomplissent un traitement qui est une partie du

modèle. L'action de ce bloc est représentée par l'icône du bloc. La plupart des blocs Extend

fonctionnent ainsi. Mais les blocs hiérarchiques fonctionnent autrement. Un bloc hiérarchique

contient d'autres blocs liés entre eux. Lorsque vous ouvrez un bloc hiérarchique, vous voyez un

groupe de blocs, qui représente une portion du modèle, ou sous-système. Les blocs hiérarchiques

permettent d'avoir des sous-systèmes dans l'objectif d'une modélisation descendante ou

ascendante.

Vous devez considérer un bloc hiérarchique comme étant un bloc contenant d'autres blocs. Les

blocs contenus peuvent être des blocs simples, ou d'autres blocs hiérarchiques, ou un mélange

des deux. A l'intérieur d'un bloc hiérarchique, les blocs sont liés comme dans un modèle, et les

blocs hiérarchiques ont des connecteurs d'entrée et de sortie comme les autres.

Il y a beaucoup d'emplois pour des blocs hiérarchiques :

• Si vous avez un modèle complexe avec plusieurs dizaines de blocs, vous pourrez utiliser

des blocs hiérarchiques pour simplifier le modèle en faisant des regroupements

fonctionnels de blocs. Ces sous-ensembles peuvent ensuite être réutilisés dans d'autres

modèles.

• Au lieu de montrer tous les détails d'une opération, vous pouvez représenter des étapes

essentielles. Pour montrer l'intérieur d'une étape, il suffit de double-cliquer sur le bloc

hiérarchique.

• En construisant un modèle, vous pouvez partir des hypothèses les plus simples jusqu'aux

règles les plus fines en créant de nouveaux niveaux hiérarchiques. Cela vous aide à

structurer votre pensée et facilite la compréhension de modèles alors même qu'ils sont de

plus en plus complexes.

45

7.2 Modèles

7.2.1 Gamme de fabrication

Figure 32 : Gamme de fabrication US

Type : Exercice

Enoncé : un atelier possède 4 machines et traite 4 références différentes ayant chacune une

gamme de fabrication propre. Elles doivent passer respectivement :

• Ref1 : M4 � M3 � M1

• Ref2 : M1 � M2

• Ref3 : M1 � M2 � M3 � M4

• Ref4 : M2 � M3 � M4

Chaque minute, une autre référence arrive: 1, 2, 3, 4, 1, 2, …

But : Utiliser les blocs ‘Catch Item’ et ‘Throw Item’


1. Envoyer des entités dépendant d'un attribut : Dans les blocs ‘Throw Item’, le bloc ‘Catch

Item’ auquel les entités doivent être envoyés, est déterminé au moyen d’un attribut.

2. Changer l'animation des entités : De nombreux blocs comportent des possibilités

d'animation. Le texte d'aide de ces blocs dit s'ils sont animés ou non, et comment. Les

blocs utilisés dans les modèles discrets permettent de représenter les éléments du flux par

une icône que l'on voit se déplacer de bloc en bloc au fur et à mesure de sa progression

dans le modèle, si l'animation est sélectionnée dans le menu Simulation. L'animation n'est

1

2

46

pas montrée par défaut parce que cela ralentit la simulation, et que vous n'en avez pas

toujours besoin. Par défaut, le symbole utilisé est un cercle vert, mais c’est possible de

modifier les symboles en ajoutant ses propres images graphiques.

Blocs introduits :

1. Throw Item : Ce bloc "envoie" des entités à un bloc ‘Catch Item’. N'importe quel

nombre de blocs ‘Throw Item’ peuvent envoyer leurs entités à un unique bloc ‘Catch

Item’. Les entités sont transmises sans connecteur, même via des blocs hiérarchiques. Le

lien entre blocs peut se faire en spécifiant le label du bloc ‘Catch Item’ correspondant, ou

à partir d'une valeur d'attribut.

2. Catch Item : Ce bloc "reçoit" les entités envoyées par un bloc ‘Throw Item’. L'emploi des

blocs ‘Throw Item’ et ‘Catch Item’ peut remplacer des blocs ‘Select Item In’, même d'un

niveau hiérarchique à l'autre.

Commentaire : Cette première solution n’utilise pas encore la hiérarchie, mais est intéressant

parce qu’elle montre très bien l’utilité des deux blocs introduits, que l’on utilise beaucoup dans

des blocs hiérarchiques. Si on devrait faire le modèle avec des liens au lieu d’avec ces blocs, le

résultat devient illisible :

Figure 33 : La solution avec des vrais liens

47

7.2.2 Gamme de fabrication hiérarchique

Figure 34 : Gamme de fabrication hierarchique US

Type : Exercice

Enoncé : Même que pour ‘Gamme de fabrication US’

But : Faire un beau modèle qui utilise la hiérarchie.


Animer des blocs hiérarchiques : Le modèle est composé de 6 blocs hiérarchiques : Arrivées,

Machines 1 à 4 et Sortie. Tous ces blocs contiennent des autres blocs. Prenons par exemple le

bloc ‘Machine 1’ :

48

Figure 35 : Structure de 'Machine 1'

Tous les blocs qui comportent des possibilités d’animation, sont aussi capables d’animer le bloc

hiérarchique duquel ils font partie. Le bloc hiérarchique ‘M1’ contient 5 blocs, dont deux qui

l’animent :

• Queue : Affiche son contenu

• Animate Value : Affiche l’icône d’une machine lorsqu’il y a une entité dans le bloc

‘Activity’

Blocs introduits :

1. Animate Value : S'anime, ou montre une image, ou déroule un film en fonction des

valeurs reçues à son connecteur.

1

49

8 Règles de gestion de l’atelier

8.1 Introduction

Dans certains systèmes de production le contrôle des flux, parfois appelé équilibrage des flux, est

un enjeu majeur. En effet un mauvais équilibrage peut entraîner l’arrêt de machines (si elles ne

reçoivent plus de matière de l’amont ou si elles sont bloquées par l’aval), arrêt qui à son tour peut

avoir des conséquences : perte de production à cause du redémarrage progressif des machines

(courbe d’accélération), perte de production car une machine produit du rebut au redémarrage,

usure prématurée et donc problème de fiabilité des machines à cause des arrêts et redémarrages,

etc.

Pour ces raisons, beaucoup de règles de gestion de l’atelier existent dans l’industrie. Il est évident

que ces règles doivent être appliquées dans les modèles. Dans tous les cas, elles sont souvent le

point le plus difficile à modéliser, car elles sont toujours particulières et parce que le spécialiste du

logiciel ne trouvera pas une fonction tout faite qui puisse fournir quelque chose comme : « si le

poste 1 en est à plus de la moitié de l’ordre de fabrication, que la référence suivante est B131 et

que l’on est à moins d’une heure du changement d’équipe, on fait attendre l’ordre de fabrication

pour le traiter sur ce poste, sinon on l’envoie sur le poste 2 ». De toute façon, c’est utile de

parcourir quelques fonctions tout faites dans Extend.

8.2 Modèles

8.2.1 Machine de secours 1

Figure 36 : Machine de secours 1 US

1

50

Type : Exemple

Enoncé : Un atelier se compose de 2 machines identiques, dont l’une n’est utilisée qu’en cas de

surcharge, c’est-à-dire quand il y a 10 pièces dans le stock amont. A ce moment là, la 2ème

machine se met en route jusqu’à ce que le nombre de pièces en attente soit redescendu à 5.

Concepts introduits : Asservissement : seuil haut et bas

Blocs introduits :

1. Decision : Ce bloc prend une décision en fonction des entrées et d'une logique qui doit

être précisé dans le dialogue. Ici, le bloc sort un 1 dès qu’il y a 10 pièces dans la file

d’attente jusqu’à le moment qu’il n’y reste que 5.

Figure 37 : Traceur Machine de secours 1

Blocs erronés : ‘Gate’ (rend un message d’erreur)



51

Type : Exemple



machine se met en route pendant 10 minutes.

Concepts introduits : Asservissement : une durée




Type : Exemple



machine se met en route et produit 10 pièces avant de s’arrêter de nouveau.

Concepts introduits : Asservissement : une quantité


52



Type : Exercice

Enoncé : Même que pour l’exemple ‘machine de secours 1 US’

But :

1. Premier étape : Décrire le pilotage dans le logique Grafcet

2. Deuxième étape : Résoudre l’exercice dans Extend

Concepts introduits : Asservissement : une boucle Grafcet : l’entité qui circule dans cette boucle

représente l’autorisation de passage des produits vers la machine de secours.

Figure 41 : Grafcet ‘Machine de secours 4 US’

53


Commentaire : Introduit les principes du pilotage Grafcet, qui sont utilisés fréquemment dans

des modèles industriels.

8.2.5 Maintenance

Figure 42 : Maintenance US

Type : Exercice

Enoncé : Une machine produit une pièce toutes les 65 secondes. Les pièces ainsi produites sont

stockées en aval de la machine en attendant d’être consommées (une demande client arrive toutes

les 1.5 minutes). La machine doit être nettoyée régulièrement. Elle peut fonctionner sans

interruption pendant une heure. Puis, si le stock aval atteint le seuil de 20 produits, on arrête la

machine pour la nettoyer pendant 1/2 heure. Quoi qu’il arrive, on nettoie la machine après 2

heures de fonctionnement.

1

54


1. Utiliser préemption : Il s’agit d’une option dans le bloc ‘Activity’. Les entités peuvent être

libérées prématurément si un autre bloc envoie une valeur supérieure à 0,5 sur le

connecteur d'entrée I. Elles sortent alors par le connecteur de sortie en bas. S'il n'y a pas

d'interruption, l'entité arrivée le plus tôt avec le plus petit délai est transmise la première,

par le connecteur de sortie en haut. Cette option est utilisée dans le bloc ‘Activity’ dans la

boucle Grafcet. L’entité qui circule dans cette boucle est libérée prématurément si le stock

atteint le seuil de 20 pendant qu’elle se trouve dans le bloc.

2. Prévenir que des entités attendent dans le bloc Batch : Le bloc ‘Batch’ peut obliger les

entités de certains flux spécifiés à attendre à l'extérieur. Cette option doit rester inutilisée

pour au moins un des flux. Dans cet exercice, l’option est utilisée pour les clients. Pour

prévenir que les entités ‘produits’ doivent attendre trop long dans le bloc ‘Batch’, on laisse

passer une telle entité que s’il y a une entité ‘client’ dans la file d’attente. Ainsi, les calculs

pour les temps dans les files d’attente restent représentatifs.

Blocs introduits :

1. Batch : Permet de réunir en une seule entité des entités provenant de différents flux. Utile

pour synchroniser des ressources, et combiner différents sous-ensembles d'un tout. Le

dialogue permet de spécifier le nombre d'entités à prélever sur chaque flux afin de

produire une entité en sortie.

Blocs erronés : ‘Gate’ (rend un message d’erreur) et ‘Activity’ (préemption ne marche pas)

Figure 43 : Grafcet ‘Maintenance US’

55

9 Exercices récapitulatifs

9.1 Introduction

Si les stagiaires n’ont pas un cas concret personnalisé qu’ils aimeraient résoudre avec l’assistance

des enseignants, on leur propose des exercices récapitulatifs.

9.2 Modèles

9.2.1 Final 1

Figure 44 : Final 1 US

Type : Exercice

Enoncé : Même que l’exercice ‘Gamme de fabrication US’, mais les modifications suivantes

doivent être apportées :

• Il y a toujours des pièces à traiter disponibles en entrée du système.

• On considère qu’en moyenne chaque référence représente 25% des pièces.

• On commence le traitement d’une nouvelle pièce uniquement si tous les stocks

intermédiaires contiennent moins de 4 pièces.

Blocs erronés : ‘Gate’ (rend un message d’erreur), ‘Ressource Item’ (bloque la simulation après

avoir sorti quelques entités) et ‘Executive’ (bloque la simulation à cause de problèmes avec les

attributs)

56

9.2.2 Final 2


Type : Exercice

Enoncé : Même que l’exercice ‘Final 1 US’, mais les modifications suivantes doivent être

apportées :

• Le programme de production est défini dans une table de la base de données. Chaque

ligne du programme est définie par une référence et une quantité à traiter.

• On souhaite pouvoir modifier librement le nombre de lignes de ce planning.

Blocs introduits :

1. Data specs : Ce bloc donne le nombre de lignes ou colonnes dans une base de données. Il

est très utile pour lire des bases de données qui peuvent encore être modifié après la

construction du modèle.



attributs)

1

57

9.2.3 Final 3


Type : Exercice

Enoncé : Même que l’exercice ‘Final 2 US’, mais les modifications suivantes doivent être

apportées :

• Les gammes de fabrication sont définies dans la base de données.

• De plus on souhaite pouvoir introduire la référence suivante :

Ref5 : M4 � M3 � M4 � M2



attributs)

Figure 47 : Structure de la base de données

58

10 Exploitation

10.1 Introduction

C’est hors de la partie proprement informatique qu’une étude de simulation requiert le plus de

temps et de savoir-faire. On peut découper – de manière un peu artificielle – un projet de

simulation avec l’enchaînement de phases suivant :

• Définition des objectifs (cahier des charges)

• Collecte et analyse des données

• Rédaction d’un dossier d’analyse fonctionnelle

• Validation

• Analyse organique et modélisation initiale

• Validation et tests

• Exploitation du modèle : jeux de simulations

• Analyse des résultats

Jusqu’à ici, on s’est concentrée sur la modélisation. Elle peut se faire rapidement, si les étapes

précédentes ont été suivies rigoureusement, et en fonction de l’ambition du modèle ainsi que de

l’outil employé.

Dans ce chapitre, on va voir quelques outils d’exploitation des modèles. Cette phase est réalisée

par l’équipe de modélisation ou bien par les utilisateurs du modèle, à condition d’avoir préparé

pour eux une interface d’exploitation facile à utiliser. Attention cependant : plus l’interface mâche

le travail de l’utilisateur en lui aménageant des boîtes noires où tout se passe sans son

intervention, moins bonne est la compréhension du modèle, et donc l’efficacité à établir le lien

entre les causes et les effets.

Dans le planning d’exploitation du modèle, il faut prévoir le temps pour lancer toutes les

simulations prévues, et s’attendre à des temps de calcul longs. L’exécution d’une simulation dure

facilement plusieurs heures, et si l’on doit lancer 10 scénarios différents, il faudra compter sur une

disponibilité machine pendant plusieurs jours (et nuits), avant même d’analyser les résultats.

Cette étape s’apparente à la conduite d’une série d’expériences, qui au lieu de se passer en

laboratoire, se déroulent sur ordinateur. Un plan d’expérience est indispensable pour simuler

efficacement. Le plan aura été formulé dans le document d’analyse fonctionnelle et devra être

suivi avec minutie, en notant précisément le contexte de chaque expérience : hypothèses,

matériel, date et heure.

59

Dans Extend, il y a quelques outils qui facilitent le lancement automatique de séries de calculs,

soit en permettant de lancer ses simulations « par lots », soit en faisant varier des paramètres selon

des critères définis. Les outils sont appliqués sur des modèles dans la version V6, parce que la

version V7 contenait encore trop de bugs au moment de l’application.

10.2 Analyse de sensibilité

10.2.1 Introduction

L'analyse de sensibilité (ou de scénarios) permet de voir l'effet de la variation d'une ou plusieurs

variables en permettant de lancer plusieurs simulations de suite en modifiant à chaque fois la

valeur d'un paramètre. Cela permet de tester complètement l'implication d'une variable sur le

système et de repérer les résultats extrêmes ainsi que la moyenne d'apparition de certaines valeurs

critiques.

Extend permet de spécifier explicitement la manière dont certains paramètres doivent changer.

L'analyse de sensibilité fonctionne avec tous les champs numériques de saisie. On peut faire

varier autant de valeurs de dialogue que l’on veut. Il vaut mieux cependant de ne travailler que sur

une ou deux valeurs à la fois pour plus de clarté dans l'analyse des résultats.

10.2.2 Exemple des batteries

Comme exemple, on va utiliser un problème de dimensionnement patrimonial :

Une station service de recharge et échange de batteries de véhicules électriques cherche à

dimensionner son parc de batteries. Les véhicules clients appartiennent à diverses administrations

et utilisent tous le même type de batteries. Les véhicules arrivent, déposent 6 batteries déchargées

et doivent repartir avec 6 batteries chargées. Des relevés statistiques ont montrés que le nombre

de véhicules se présentant par heure suit une loi de poisson de moyenne 10 entre 8h et 20h et une

loi de poisson de moyenne 2 entre 20h et 8h.

Lorsqu’un véhicule se présente il a une chance sur 5 d’être prioritaire (services de santé,

pompiers). Il est servi avant d’autres véhicules qui éventuellement attendent déjà. La station est

ouverte 24h/24, mais pour des raisons de coût de l’électricité on a décidé de ne recharger les

batteries qu’en heures creuses (23h-7h). Il faut entre 6h et 9h pour recharger une batterie (réparti

uniformément).

La station dispose de 1000 postes de charge disponibles pouvant fonctionner en parallèle. En

plus du temps de chargement il faut positionner les batteries sur leurs postes de charge et les

60

enlever lorsque la charge est terminée. Ces opérations requièrent un opérateur, qui y met de 2 à 3

minutes suivant une loi uniforme. Les opérateurs travaillent en 2x8 (de 7h à 23h). En partant à

23h la charge des batteries sur leur poste démarre automatiquement.

Le but est dimensionner le parc de batteries neuves et le nombre d’opérateurs pour qu’un

véhicule prioritaire ait 98% de chances d’être servi en moins de ½ heure. Les batteries sont

vendues par lots de 25.

Figure 48 : Exemple des batteries

Le modèle est fait dans la version V6 parce que ce n’était pas encore possible de faire un modèle

d’un tel volume sans fautes dans la version V7. Le structure du bloc hiérarchique ‘batteries’ est

aussi affiché dans Figure 48.

On fera des simulations d’un mois (=720h). Dans Figure 49, l’utilisation des opérateurs (en

rouge) et le nombre de batteries chargées disponibles (en vert) sont affichés. On peut voir qu’on

simule assez longtemps dans un régime stable.

61

Figure 49 : Traceur exemple des batteries

Le but est que le pourcentage de véhicules prioritaires qui sont servis en moins d’une demi-heure

atteint le seuil de 98%. Ce chiffre est notre valeur objective. Il y a deux facteurs avec lesquels on

peut jouer pour atteindre le but : le nombre d’opérateurs et le nombre de batteries disponible

dans la station.

10.2.3 Application

Il n’y a que deux paramètres, mais comme ils sont illimités, en théorie, le nombre de

combinaisons possibles est infini. Pour avoir une idée des valeurs optimales, on peut commencer

les simulations avec 10000 batteries et chercher le nombre d’opérateurs minimal pour lequel le

nombre de batteries se stabilise. Comme on dispose d’un ‘traceur multisim’ qui peut tracer 4

courbes, on fait 4 simulations, dans lesquels le nombre d’opérateurs varie de 1 à 4 :

Figure 50 : Dialogue de l'analyse de sensibilité

62

Figure 51 : Le traceur multisim

On peut voir qu’il faut à moins 4 opérateurs.

Dans ce cas, le nombre de batteries chargées disponible, n’est jamais plus bas que 8500. On peut

par conséquence supposer que le nombre de batteries que la station doit acheter, se trouve entre

500 et 2500. On fait une nouvelle analyse de sensibilité sur le nombre de batteries disponibles.

Comme on n’a pas besoin d’un graphique, on peut faire autant de simulations que l’on veut. Par

contre, pour diminuer le temps de calculs, on augmente le nombre de batteries avec 250 après

chaque simulation. Comme ça, le nombre de simulations est limité à 9. Pour écrire le pourcentage

de véhicules prioritaires servis à temps après chaque simulation, on utilise le bloc ‘File Out’. On

obtient le résultat suivant :

Figure 52 : Résultats deuxième analyse de sensibilité

La troisième simulation atteint notre but le plus proche. Cette simulation utilisait 1000 (=500+

(3-1)*250) batteries.

Maintenant on veut connaître le nombre optimal avec une précision de 25. On fait varier notre

paramètre entre 900 et 1100 :

63

Figure 53 : Résultats deuxième analyse de sensibilité

Le nombre optimal pour notre paramètre est 1000 (=900+ (5-1)*25) batteries.

Notre station a donc besoin de 4 opérateurs et 1000 batteries. Ca donne un résultat de 98,29%

des véhicules prioritaires qui sont servies en moins d’une demi-heure.

10.2.4 Conclusion

Dans l’exploitation de ce modèle, on a fait deux erreurs :

1. On ne sait pas quel précision a ce résultat, parce qu’on n’a fait qu’une simulation par

valeur du paramètre.

2. On n’a pas tenu compte de l’interaction qu’il peut y avoir entre les deux paramètres.

L’analyse de sensibilité est donc un outil qui est utile pour avoir une idée des valeurs optimales

des paramètres, mais pas pour faire des conclusions fondées.

10.3 L'optimisateur

10.3.1 Introduction

La simulation de flux ne permet pas d’optimiser (c'est-à-dire automatiquement fournir la

configuration optimale des paramètres) un système de production ; elle permet de reproduire son

fonctionnement et par conséquent de prédire l’impact de modifications des valeurs des

paramètres. Il est toujours possible d’optimiser par essais successifs, mais cela est peu probable,

surtout si beaucoup de solutions sont acceptables. Ce n’est pas un retard de la simulation de flux

par rapport à d’autres techniques mais c’est inhérent à son caractère empirique. L’optimisation

pourra dans certains cas être obtenue grâce à des techniques mathématiques plus sophistiquées,

par exemple issues de la recherche opérationnelle. Par contre, leur utilisation pour des situations

64

industrielles réelles va nécessiter le plus souvent des simplifications telles (approximations) que

l’on va enfin obtenir la solution optimale à un problème qui n’est qu’une approximation du

problème initiale. On peut se demander s’il n’est pas préférable d’obtenir une bonne solution du

vrai problème…

10.3.2 L’optimisateur d’Extend

En effet, l’optimisateur est un outil qui nous permet de déterminer automatiquement des

paramètres correspondant à des bonnes solutions. Il accompli ceci en lançant la simulation à

plusieurs reprises jusqu’à atteindre une solution acceptable. L’optimisateur livré avec Extend

utilise un algorithme génétique afin de réduire le nombre de simulations nécessaires.

Le problème à optimiser est habituellement décrit par une fonction objective, généralement

équivalente à des coûts ou profits, qu’on cherche à maximiser ou minimiser.

La contrepartie de l’optimisation est la nécessité de lancer beaucoup de simulations pour trouver

une solution qu’on aurait pu trouver dans certains cas manuellement avec moins de simulations.

De plus il se peut que l’optimisateur converge vers une solution optimale localement. En effet, il

n’existe pas d’algorithme d’optimisation qui garantisse de trouver une solution optimale en un

temps fini. Plus on accorde de temps à l’optimisateur, plus on aura de chance de converger vers

une solution optimale.

La plupart des algorithmes capables de résoudre des problèmes stochastiques (c’est à dire avec

une composante aléatoire) utilisent une population initiale de solutions possibles. Chaque

solution est évaluée en lançant la simulation à plusieurs reprises, ce qui permet de générer des

moyennes et de trier les solutions. Les meilleures solutions sont alors utilisées pour générer des

solutions légèrement différentes qui pourraient s’avérer meilleures. Chaque nouvelle solution

dérivée est appelée génération, parce qu’elle est une combinaison de deux solutions de la

population : les parents. Par contre, pour échapper aux optimums locaux, parfois une ‘mutation

génétique’ est introduite : un des valeurs des paramètres ne vient pas des deux ‘parents’. Cette

démarche est répétée jusqu’à ce que probablement plus aucune meilleure solution ne soit en vue.

Le problème de tout algorithme d’optimisation est l’incapacité de dire si une solution optimale à

été atteinte ou même envisagée. Une bonne approche est d’autoriser l’algorithme à continuer la

génération de nouvelles solutions "assez longtemps" pour déterminer si les solutions convergent.

De plus, lancer plusieurs fois une même optimisation permet de déterminer si l’algorithme

aboutit toujours à des solutions semblables, ce qui permet de réduire le risque d’avoir abouti à

une solution sous-optimale.

65

10.3.3 Application

On reprend l’exemple des batteries (voir 10.2.2)

On veut arriver à un pourcentage de 98% de véhicules prioritaires servies à temps. Notre

fonction d’objectif devient par conséquence :

98,011

xZ −−=

Cette fonction Z est maximale quand la valeur de x est égale à 0,98. Le code pour calculer cette

fonction dans Extend devient :

MaxProfit=1.0 - RealAbs(1.0-Prio_tard/0.98);

Les paramètres que l’optimisateur peut changer pour atteindre ce but sont le nombre de batteries

disponible dans la station ‘Bat’ et le nombre d’opérateurs ‘Ops’. Pour ‘montrer’ à l’optimisateur

que ces valeurs sont des paramètres d’entrée, il faut mentionner des limites inférieures et

supérieures. Comme on n’a aucune idée des valeurs, on choisit les limites suivantes :

100000

104

≤≤≤≤

Bat

Ops

Il faut seulement mettre la limites inférieure pour le nombre d’opérateurs sur 4, parce qu’on

n’arrive pas à un régime stable avec moins de 4 opérateurs (voir Figure 51)

On rempli les données sur l’onglet ‘Set Cost’.

Figure 54 : Onglet 'Set Cost' du bloc Optimisateur

Pour le paramètre ‘Bat’, il y a encore la contrainte que les batteries ne sont vendues que dans des

lots de 25. On peut spécifier cette contrainte sur l’onglet ‘Constraints’ :

66

Figure 55 : Onglet 'Constraints' du bloc Optimisateur

Si on lance l’optimisateur avec ces options, on obtient le résultat suivant :

Figure 56 : Résultats optimisateur

Après plus que 12 heures de calcul et 3831 simulations, l’optimisateur trouve une population de

solutions acceptables. On peut dire qu’il n’a pas été efficace, parce que le nombre de solutions

possibles n’est que 2807 :

67

( ) 2807125

100001410

__

=

+×+−=

×=

N

BatniveauxOpsniveauxN

En plus, il se contente de nous donner une population de 10 solutions, dont il n’y a que 4

solutions différentes.

En fait, ce n’est pas étonnant. Si on regarde les résultats obtenus avec l’analyse de sensibilité, on

peut supposer que notre fonction objective a un optimum local à environ 1000 batteries et 4

opérateurs. Ca donne un pourcentage de véhicules prioritaires servis à temps de 98%. Si on baisse

ces valeurs, le pourcentage baisse très vite. Si on hausse ces valeurs, le pourcentage devient 100%

et y reste. Traduit en notre fonction objective, ça donne une courbe symbolique comme dans

Figure 57, avec un optimum qui est très difficile à trouver.

0

0,2

0,4

0,6

0,8

1

Solutions possibles

Fonc

tion

obje

ctiv

e

Figure 57 : Approximation de la fonction objective

Alors, ce qu’il s’est passé, c’est que l’optimisateur a trouvé à la fin de son calcul une solution du

début de la courbe dans la Figure 57. Apparemment, c’était la solution avec 5 opérateurs et 1100

batteries. Après quelques mutations et générations, il a trouvé 9 autres solutions avec une valeur

de fonction objective assez proche pour arriver à une convergence de 98,60%.

Si on change les paramètres de l’optimisateur, peut-être qu’il trouvera des solutions meilleures,

mais ça prendra sans doute beaucoup de temps de calcul. Il vaut mieux de l’aider un peu : si on

est capable de localiser l’optimum de manière approximative en utilisant des autres méthodes ou

la connaissance du problème réel, on peut saisir des limites plus intelligentes et l’optimisateur va

trouver de bonnes solutions. On peut par exemple se baser sur les résultats de l’analyse de

sensibilité dans le chapitre 10.2.3. On choisit les limites suivantes :

68

1100900

64

≤≤≤≤

Bat

Ops

Après 20 minutes de calcul, on obtient les résultats suivants :

Figure 58 : Résultats optimisateur

L’optimisateur nous donne une population de 10 bonnes solutions. Par contre, certaines

solutions apparaissent plusieurs fois. Ils ont une valeur différente pour la fonction objective

‘MaxProfit’ et pour ce raison, l’optimisateur les voit comme des différentes solutions. Les 10

solutions ont un degré de convergence de 99,6%. Ca veut dire qu’ils sont très proches et qu’on

peut choisir entre les 10 solutions sans que la fonction objective change trop. Par conséquence,

on peut choisir la solution basé sur des autres critères, comme les coûts.

L’optimisateur a effectué 121 simulations, alors qu’il n’y avait que 27 solutions possibles.

( ) 27125

9001100146

__

=

+−×+−=

×=

N

BatniveauxOpsniveauxN

69

Pour faire un plan factoriel complet avec 5 simulations par solution, nous devons lancer que 135

simulations et dans ce cas-là, on est sûr de trouver l’optimum. L’optimisateur ne donne donc pas

preuve d’une grande efficacité.

10.3.4 Conclusion

Cet exemple montre bien les avantages et désavantages de la méthode. L’avantage est que la

méthode est très facile à essayer et qu’elle donne une population de bonnes solutions et non pas

une seule bonne solution. Comme la simulation est un outil d’aide à la décision et pas un outil de

décision, c’est utile de pouvoir choisir entre plusieurs bonnes solutions. Par exemple, il est clair

qu’on préfère une solution avec 4 opérateurs qui n’atteint pas tout à fait le but de 98% sur une

solution avec 5 opérateurs qui atteint le but. En plus, l’optimisateur a fait plusieurs simulations

pour chaque solution et nous fournit la précision du résultat obtenu. C’est essentiel, parce que

pour les problèmes stochastiques, un chiffre ne dit rien sans que l’on connaisse aussi sa précision.

Il faut dire qu’on a choisi une fonction objective plutôt particulière dans notre exemple. Pour des

problèmes plus généraux, cette méthode permet de trouver des optimums locaux ou globaux sans

que l’utilisateur n’ait aucune idée des valeurs optimales pour les paramètres.

Le grand désavantage est naturellement que le résultat et l’efficacité ne sont pas garantis. Il se

peut que l’optimisateur converge vers une solution optimale localement et on n’a aucune idée s’il

y a une solution optimale globalement. Comme on a vu dans notre exemple, l’optimisateur n’est

pas toujours efficace, mais il faut dire qu’il n’existe pas d’algorithme d’optimisation qui garantisse

de trouver une solution optimale en un temps fini.

10.4 Effectuer des plans d’expérience via Excel

10.4.1 Introduction

Les essais de mise au point d’un produit ou d’un processus font partie intégrante du métier des

ingénieurs et des techniciens d’études et de fabrication. Ceux-ci sont fréquemment amenés à

rechercher les valeurs de paramètres afin d’obtenir les performances désirées.

Un plan d’expériences est une suite d’essais entièrement organisée à l’avance de manière à

déterminer, en un minimum d’essais et avec un maximum de précision, l’influence des différents

paramètres pour optimiser les performances du système étudié.

70

10.4.2 Lien avec Excel

Extend peut utiliser l’automation OLE en tant que serveur d’automation ou client

d’automatisation. OLE (Object Linking and Embedding) est une technique mise au point par

Microsoft pour faciliter l’échange de données entre les programmes sous Windows.

Ici, on utilise Extend comme serveur d’automation OLE. Ca veut dire qu’Excel contrôle

l’application Extend via OLE. La première action est de créer l’instance pour l’objet Extend.

Après, on peut utiliser trois méthodes OLE, qu’on expliquera ici. Le code utilisé est VBA (Visual

Basic for Applications), qui est fourni avec Excel. Les codes complets sont ajoutés dans

Appendice A et B.

10.4.2.1 Saisir une variable en Extend

On utilise la méthode ‘Poke’, qui requiert trois arguments du type chaîne de caractères :

• Sujet : nom du modèle ou « system » si le modèle ne doit pas être spécifié

• Entité : nom du variable dans Extend, nombre du bloc du variable, ligne, colonne

• Valeur : on prend la valeur dans Excel que l’on veut utiliser et la transforme en chaîne de

caractère.

Exemple : ExtendApp.Poke "System", "maxLen:#3:0:0", Str(Worksheets("Lien Extend").Range("C4").Value)

10.4.2.2 Obtenir une variable d’Extend

On utilise la méthode ‘Request’, qui requiert les arguments ‘Sujet’ et ‘Entité’ dans la même

manière que la méthode ‘Poke’. Elle retourne une valeur comme chaîne de caractères, donc pour

l’utiliser dans Excel, il faut la transformer en valeur.

Exemple :

Worksheets("Lien Extend").Range("C6").Value = Val(ExtendApp.Request("System", "ShowResult:#159:0:0"))

10.4.2.3 Exécuter du code

On utilise la méthode ‘Execute’, qui a comme argument le code à exécuter, par exemple ouvrir le

modèle ou lancer une simulation.

Exemple :

ExtendApp.Execute "OpenExtendFile(" + """" + lsModelPath + "resto rapide Excel.mox" + """" + ");"

71

10.4.3 Application : Plan factoriel complet

Un plan d’expérience factoriel complet étudie toutes les combinaisons possibles des niveaux de

facteurs essayés. Accessoirement, ils permettent de trouver directement la meilleure combinaison

des niveaux de facteurs puisque toutes les combinaisons possibles sont essayées. C’est la solution

la plus sûre, mais les délais et les coûts d’expérimentation deviennent prohibitifs dès que l’on

dépasse 3 ou 4 facteurs. Un des grands avantages de la simulation par contre est que le temps

pendant lequel on expérimente ne coute pas cher, surtout si on arrive à automatiser les

expériences. Ca nous permet de choisir pour les plans factoriels complets.

Si on prend l’exemple des batteries (voir 10.2.2), on peut par exemple créer un plan des 2

paramètres aux niveaux suivants :

• Nombre d’opérateurs : 4, 5 ou 6

• Nombre de batteries : 950, 975, 1000, 1025 ou 1050

Si on choisit à lancer 15 simulations par solution, le nombre de simulations à exécuter est 225

(=3x5x15). Ca donne les résultats suivants :

Ops Bat Moyenne Ecart-type

Solution 1 950 95,12% 1,75%

Solution 2 975 96,80% 1,07%

Solution 3 1000 98,53% 0,64%

Solution 4 1025 98,79% 0,97%

Solution 5

4

1050 99,06% 0,70%

Solution 6 950 95,60% 1,55%

Solution 7 975 97,00% 1,13%

Solution 8 1000 98,30% 0,89%

Solution 9 1025 98,99% 0,76%

Solution 10

5

1050 99,62% 0,34%

Solution 11 950 94,74% 2,37%

Solution 12 975 97,34% 1,30%

Solution 13 1000 97,90% 1,42%

Solution 14 1025 99,05% 0,97%

Solution 15

6

1050 99,51% 0,43% Tableau 1 : Résultats plan factoriel complet

72

% de véhicules prioritaires servis à temps

92,00%

93,00%

94,00%

95,00%

96,00%

97,00%

98,00%

99,00%

100,00%

950 975 1000 1025 1050

Nombre de batteries disponible à la station

4 opérateurs

5 opérateurs

6 opérateurs

Figure 59 : Résultats plan factoriel complet

10.4.4 Application : Plan factoriel fractionnaire Taguchi

10.4.4.1 Introduction

La méthode des plans d’expériences Taguchi est certainement l’outil le plus puissant et pourtant

accessible à tous pour atteindre simultanément deux objectifs à priori antinomiques : améliorer

les paramètres d’un système et réduire la durée de leur mise au point.

Une des contributions de G. Taguchi, parmi les plus remarquables, est d’avoir vulgarisé les

techniques des plans d’expériences, en proposant une panoplie de plans standards. Ces plans ont

tout la caractéristique de l’orthogonalité, qui permet d’isoler les effets individuels des différents

facteurs testés simultanément dans des conditions variées.

Un plan orthogonal factoriel fractionnaire permet d’obtenir (presque) autant d’informations

efficaces qu’un plan d’expériences factoriel complet équivalent, tout en réduisant

considérablement le nombre d’essais à effectuer. Les effets calculés ne sont pas purs car il s’y

ajoute généralement, sans qu’on puisse les identifier et les isoler, les interactions existant

éventuellement avec les autres facteurs.

La méthode est donc très pratique et économique, mais relativement imparfait, pour obtenir

d’excellents résultats.

73

10.4.4.2 Exemple du resto rapide

Pour illustrer cette méthode, l’exemple des batteries n’a pas assez de paramètres. On introduit

l’exemple du resto rapide :

Un restaurant comporte :

• 32 places de parking (N)

• 8 places assises le long d’un « bar » (pour les clients seuls) (T1)

• 16 tables de deux (T2)

• 8 tables de quatre (T4)

• 6 tables de six (T6)

Entre 11h et 14h les clients arrivent en voiture en moyenne toutes les minutes (distribution

exponentielle). Il n’y a pas de vente à emporter dans la salle (cette fonction est assurée par le

système de drive).

S’ils trouvent une place libre sur le parking ils se garent. Sinon ils repartent et on a perdu le client.

Chaque voiture compte de manière aléatoire :

• 1 client : 15%

• 2 clients : 30%

• 3 clients : 25 %

• 4 clients : 15%

• 5 clients : 10%

• 6 clients : 5%

On considère que chaque groupe est servi en 5 minutes. Une fois servi il cherche une table.

Chaque groupe, s’il trouve une table à son goût, va séjourner de 5 à 30 minutes (Réelle uniforme)

dans le restaurant. Un groupe qui ne trouve pas de table qui lui convient repart furieux avec sa

commande.

• Les groupes de 1 vont soit au bar, soit à une table de 2 libre, soit à une table de 4 libre,

soit à une table de 6 libre

• Les groupes de 2 vont soit à une table de 2 libre, soit à une table de 4 libre, soit à une

table de 6 libre

• Les groupes de 3 vont soit à une table de 4 libre, soit à une table de 6 libre

• Les groupes de 4 vont soit à une table de 4 libre, soit à une table de 6 libre

• Les groupes de 5 vont soit à une table de 6 libre, soit à une table de 4 libre (dans cet ordre

de préférence. Ils acceptent de se serrer à 5 sur une table de 4).

• Les groupes de 6 vont obligatoirement à une table de 6 libre.

74

Figure 60 : modèle du resto rapide

Le chef du restaurant veut savoir comment il doit changer le nombre de places de parking et de

tables. Il propose les changements suivants :

N T1 T2 T4 T6

Niveau 1 28 6 12 6 4

Niveau 2 30 7 14 7 5

Niveau 3 34 9 18 9 7

Niveau 4 36 10 20 10 8 Tableau 2 : Matrice des paramètres

Il a calculé que chaque client qui part lui coûte 2€. Dans une voiture, il y a en moyenne 2,75

personnes. Pour chaque place de plus, indépendant du type de table, il doit trouver un autre

bâtiment qui est 4m² plus grand. Le loyer moyen est 5€/m².mois. Pour chaque place de parking

de plus, il doit trouver un parking qui est 15m² plus grand. Le loyer est 0,2€/m².mois.

La fonction objective devient :

Coût (€/mois) = (2,75 x voitures_parties + clients_partis) x 30,5 x 2

+ (4 x T1 + 8 x T2 + 16 x T4 + 24 x T6) x 5

+ 15 x N x 0,2

75

10.4.4.3 Application

Comme il y a 5 facteurs à 4 niveaux, le nombre de solutions possible est 1024 (= 45). Si on veut

exécuter plusieurs simulations par solution, le nombre de simulations à lancer devient très grand.

Techniquement, c’est possible, mais on résoudra le problème en utilisant les méthodes de

Taguchi. La matrice qu’on utilise est le ‘L16’ :

N T1 T2 T4 T6

Essai 1 1 1 1 1 1

Essai 2 1 2 2 2 2

Essai 3 1 3 3 3 3

Essai 4 1 4 4 4 4

Essai 5 2 1 2 3 4

Essai 6 2 2 1 4 3

Essai 7 2 3 4 1 2

Essai 8 2 4 3 2 1

Essai 9 3 1 3 4 2

Essai 10 3 2 4 3 1

Essai 11 3 3 1 2 4

Essai 12 3 4 2 1 3

Essai 13 4 1 4 2 3

Essai 14 4 2 3 1 4

Essai 15 4 3 2 4 1

Essai 16 4 4 1 3 2 Tableau 3 : Matrice L16

Dans Excel, c’est facile de combiner la matrice des paramètres et la matrice L16 en une matrice :

le plan d’expériences que l’on va utiliser. On lance 15 simulations par solution et obtient le

résultat suivant :

Matrice des facteurs contrôlés Résultats

N T1 T2 T4 T6 Moyenne Ecart-type S/N (dB)

Essai 1 28 6 12 6 4 2955 464 -69,52

Essai 2 28 7 14 7 5 3008 831 -69,88

Essai 3 28 9 18 9 7 3541 849 -71,23

Essai 4 28 10 20 10 8 4248 1031 -72,81

Essai 5 30 6 14 9 8 3040 849 -69,98

Essai 6 30 7 12 10 7 2867 718 -69,41

Essai 7 30 9 20 6 5 3359 360 -70,57

Essai 8 30 10 18 7 4 3017 683 -69,81

Essai 9 34 6 18 10 5 2476 114 -67,88

Essai 10 34 7 20 9 4 2727 242 -68,75

76

Essai 11 34 9 12 7 8 2684 289 -68,63

Essai 12 34 10 14 6 7 2656 562 -68,68

Essai 13 36 6 20 7 7 2794 165 -68,94

Essai 14 36 7 18 6 8 2655 190 -68,50

Essai 15 36 9 14 10 4 2474 161 -67,89

Essai 16 36 10 12 9 5 2529 381 -68,16

=y 2939 =T -69,41 Tableau 4 : Matrice des résultats

Le ratio Signal/Bruit (S/N) est l’indicateur de performance qui prend simultanément en compte :

• la valeur à minimiser : la moyenne y

• la variabilité de cette valeur, à combattre : l’écart-type s

Dans le cas d’un critère à minimiser, la formule est la suivante :

²)²log(10)(/ ysdBNS +−=

Puis on doit calculer la réponse moyenne pour chaque niveau de facteur, autant pour le ratio S/N

que pour la valeur moyenne. On prend l’exemple du paramètre N, niveau 1. Ca veut dire qu’on

doit prendre en compte tous les essais ou le nombre de places de parking est 28. Ce sont les 4

premiers essais :

S/N : 86,704

81,7223,7188,6952,691 −=−−−−=N

Coût : 34384

42483541300829551 =+++=N

L’effet du niveau 1 pour le paramètre N :

S/N : 45,1)41,69(86,7011 −=−−−=−= TNEN

Coût : 4992939343811 =−=−= yNEN

On fait les mêmes calculs pour chaque niveau de facteur. On obtient le résultat suivant :

Effet sur le ratio Signal/Bruit Effet sur la valeur mesurée

Niv 1 Niv 2 Niv 3 Niv 4

Fact.

Niv 1 Niv 2 Niv 3 Niv 4

-1,45 -0,53 0,93 1,04 N 499 131 -303 -326

0,33 0,28 -0,16 -0,45 T1 -123 -125 75 173

0,49 0,31 0,06 -0,85 T2 -181 -145 -17 343

0,10 0,10 -0,11 -0,08 T4 -33 -64 20 77

0,43 0,29 -0,15 -0,57 T6 -146 -96 25 217 Tableau 5 : Matrice des effets

Pour définir la configuration optimale des niveaux des facteurs, on doit choisir les niveaux qui

ont :

77

• un effet maximal sur le ratio Signal/Bruit

• un effet minimal sur la valeur mesurée

Ces niveaux sont marqués en jaune sur la matrice des effets. Pour le facteur T1, le choix n’est pas

évident. Le niveau 1 maximise le ratio Signal/Bruit, mais le niveau 2 minimise la valeur. Taguchi

propose de choisir le niveau qui maximise le ratio Signal/Bruit dans ce cas.

En choisissant tous les niveaux de facteurs qui ont des effets positifs sur le ratio Signal/Bruit, on

obtient les valeurs prévisionnelles du ratio Signal/Bruit et de la valeur mesurée (les coûts).

Effets des niveaux facteurs sur

Facteur Niveau Signal/Bruit Coûts

N 4 1,04 -326

T1 1 0,33 -123

T2 1 0,49 -181

T4 2 0,10 -64

T6 1 0,43 -146

Somme des effets 2,39 -840 Moyenne générale -69,41 2939 Résultat théorique -67,03 2099

Tableau 6 : Configuration proposée

Les résultats théoriques dans

Tableau 6 sont calculés en supposant que tous les effets individuels des facteurs s’additionnent

normalement (autrement dit, en considérant qu’il n’y a pas d’interactions significatives entre les

facteurs qui fausseraient en plus ou en moins l’additivité de leurs effets).

Si on lance 20 simulations avec les facteurs dans la configuration proposée, on obtient le résultat

suivant :

Matrice des facteurs contrôlés Résultats

N T1 T2 T4 T6 Moyenne Ecart-type S/N (dB)

36 6 12 7 4 2642 393 -68,53 Tableau 7 : Résultats avec la configuration proposée

Les résultats ne conviennent pas du tout avec les résultats théoriques. Pourquoi pas ? Est-ce

qu’on peut faire l’hypothèse qu’il n’y pas d’interaction dans ce cas-ci ? Non, c’est clair que le

nombre de tables de 4 personnes n’est pas indépendant du nombre de tables de 6 personnes. La

méthode qu’on a utilisée ne marche pas dans ce cas-ci. Il y a deux solutions : un plan factoriel

fractionnaire qui tient compte des interactions ou un plan factoriel complet. Comme on a un outil

pour lancer des simulations en changeant les paramètres automatiquement, on choisit la dernière

option.

78

Il y a 1024 solutions à tester. On exécute 10 simulations par solution :

…

…

Figure 61 : Résultats du plan factoriel complet

La solution optimale est l’essai 522, qui a utilisé les paramètres suivants :

N T1 T2 T4 T6 Essai 522 34 6 12 9 5

Tableau 8 : Configuration optimale

Les coûts résultants seront €2150/mois avec un écart-type de 161 (Ratio Signal/Bruit de -66,67).

10.4.5 Conclusion

En utilisant un lien entre Excel et Extend, on peut exécuter des plans d’expériences. Avec cet

outil, on est capable de lancer autant de simulations que l’on veut, en changeant les paramètres

automatiquement. Comme il est nécessaire de programmer, ce n’est pas accessible à tous, mais

c’est la solution la plus efficace. Un grand avantage par rapport à l’optimisateur est que les

résultats aident à comprendre ce qui est derrière le modèle. Par contre, c’est nécessaire d’avoir

une idée des valeurs optimales des paramètres pour savoir quelles valeurs sont à tester. Dans le

cas de paramètres numériques, ce n’est pas toujours évident.

79

11 Conclusion

Les chapitres 2 à 9 décrivent de tous les modèles utilisés dans les formations. Ils peuvent servir

comme fiches pratiques que les formateurs peuvent utiliser à côté des présentations en

PowerPoint qui ont été faites. Ces modèles forment la base de 2 formations : la première version

d’une formation de 4 jours en V7 et une formation « Delta V7 » (de V6 à V7) de 1 jour.

En même temps, des tests des versions alpha et beta ont été exécutés. Ces tests impliquaient une

procédure de feed-back rigoureuse pour signaler les erreurs reproductibles à Imagine That!,

partenaire d’1Point2. Ainsi, 1Point2 aide Imagine That ! à développer la nouvelle version.

Beaucoup d’erreurs ont déjà été résolues dans les différentes versions Alpha et Beta que Imagine

That ! envoyait.

Le stage était aussi une occasion pour 1Point2 de prendre de l’avance sur la V7. Avant la

commercialisation, ils en ont déjà obtenu un grand degré de connaissance.

Malgré l’importance du travail effectué, 1Point2 a décidé de le laisser faire par un stagiaire à cause

de son volume. Tout cela laisser faire par des consultants, coûte très cher, parce que c’est du

temps non payé. Pour la même raison, les rapports des tests envoyés à Imagine That ! étaient un

des plus détaillés parmi tous les testeurs.

L’analyse critique des méthodes d’exploitation des modèles (chapitre 10) peut servir comme base

pour une formation sur l’exploitation des modèles dans le futur. Beaucoup de clients ont déjà

demandé une telle formation.

80

Appendices

Appendice A : code VBA pour l’exploitation du modèle des batteries

Dim i As Integer 'i is the number of the current simulation for a certain set of parameters Private Sub cmdRun_Click() ' The Extend application is an object Dim ExtendApp As Object Dim GettingObject Dim lsModelPath As String lsModelPath = ThisWorkbook.Path 'initialize number of simulations i = 1 Range("F10:T25").Value = Empty Range("B10").Select 'Create an instance of Extend On Error GoTo ErrorHandler: ' If Extend is not loaded an error will be returned and the CreateObject method will be called GettingObject = 1 ' Get the active Extend object. If Extend is not open, this will cause an error ' and will go to the ErrorHandler label. Here, the CreateObject function is called Set ExtendApp = GetObject(, "Extend.Application") loadmodel: GettingObject = 0 ' open the model ExtendApp.Execute "OpenExtendFile(" + """" + lsModelPath + "Batteries Excel.mox" + """" + ");" 'start experiment: Active cell has to be the upper left cell of the matrix 'Active cell is always one of the most left cells of the matrix While ActiveCell.Value <> Empty 'set parameters for current simulation Range("C4:D4").Value = ActiveCell.Range("A1:B1").Value 'Poke the values into the dialog of the block ExtendApp.Poke "System", "NumServ:#20:0:0", Str(Worksheets("Lien Extend").Range("C4").Value) ExtendApp.Poke "System", "init:#76:0:0", Str(Worksheets("Lien Extend").Range("D4").Value) 'run simulation ExtendApp.Execute "RunSimulation(FALSE);" 'save output current simulation 'Request the dialog variable from Extend

81

Worksheets("Lien Extend").Range("C6").Value = CDbl(ExtendApp.Request("System", "ShowResult:#115:0:0")) ActiveCell.Offset(0, 3 + i).Value = Range("C6").Value If i = Range("C2").Value Then 'If enough simulations for current solution: 'reset number of simulations i = 0 'go to next solution ActiveCell.Offset(1, 0).Range("A1").Select End If i = i + 1 Wend ' Destroy the Extend object Set ExtendApp = Nothing GoTo done: ErrorHandler: If GettingObject Then ' Extend is not running (otherwise GetObject would have worked) so we ' call create object to start Extend Set ExtendApp = CreateObject("Extend.Application") GoTo loadmodel: Else MsgBox Error$ Set ExtendApp = Nothing End If done: End Sub

82

Appendice B : code VBA pour l’exploitation du modèle du resto rapide

Dim i As Integer 'i is the number of the current simulation for a certain set of parameters Private Sub cmdRun_Click() ' The Extend application is an object Dim ExtendApp As Object Dim GettingObject Dim lsModelPath As String lsModelPath = ThisWorkbook.Path 'initialize number of simulations i = 1 Range("H10:AA25").Value = Empty Range("B10").Select 'Create an instance of Extend On Error GoTo ErrorHandler: ' If Extend is not loaded an error will be returned and the CreateObject method will be called GettingObject = 1 ' Get the active Extend object. If Extend is not open, this will cause an error ' and will go to the ErrorHandler label. Here, the CreateObject function is called Set ExtendApp = GetObject(, "Extend.Application") loadmodel: GettingObject = 0 ' open the model ExtendApp.Execute "OpenExtendFile(" + """" + lsModelPath + "resto rapide Excel.mox" + """" + ");" 'start experiment: Active cell has to be the upper left cell of the matrix 'Active cell is always one of the most left cells of the matrix While ActiveCell.Value <> Empty 'set parameters for current simulation Range("C4:G4").Value = ActiveCell.Range("A1:E1").Value 'Poke the values into the dialog of the block ExtendApp.Poke "System", "maxLen:#3:0:0", Str(Worksheets("Lien Extend").Range("C4").Value) ExtendApp.Poke "System", "maxLen:#47:0:0", Str(Worksheets("Lien Extend").Range("D4").Value) ExtendApp.Poke "System", "maxLen:#61:0:0", Str(Worksheets("Lien Extend").Range("E4").Value) ExtendApp.Poke "System", "maxLen:#66:0:0", Str(Worksheets("Lien Extend").Range("F4").Value) ExtendApp.Poke "System", "maxLen:#71:0:0", Str(Worksheets("Lien Extend").Range("G4").Value) 'run simulation ExtendApp.Execute "RunSimulation(FALSE);" 'save output current simulation 'Request the dialog variable from Extend

83

Worksheets("Lien Extend").Range("C6").Value = Val(ExtendApp.Request("System", "ShowResult:#159:0:0")) ActiveCell.Offset(0, 5 + i).Value = Range("C6") If i = Range("C2").Value Then 'If enough simulations for current solution: 'reset number of simulations i = 0 'go to next solution ActiveCell.Offset(1, 0).Range("A1").Select End If i = i + 1 Wend ' Destroy the Extend object Set ExtendApp = Nothing GoTo done: ErrorHandler: If GettingObject Then ' Extend is not running (otherwise GetObject would have worked) so we ' call create object to start Extend Set ExtendApp = CreateObject("Extend.Application") GoTo loadmodel: Else MsgBox Error$ Set ExtendApp = Nothing End If done: End Sub

84

Références

[1] J-F. CLAVER, J. GELINIER et D. PITT, Gestion de flux en entreprise, Hermès, 1997

[2] J. ALEXIS et P. ALEXIS, Pratique industrielle des plans d’expériences, AFNOR, 1999

[3] Imagine That, Inc., Extend V6 User’s Guide, 2002

[4] Imagine That, Inc., Extend V6 Developer’s Reference, 2002

Réalisation de modèles de simulation à vocation...

Documents

Transcript of Réalisation de modèles de simulation à vocation...