Merci d'avoir pris un peu de temps, regardez cette vidéo.
Je suppose que vous êtes ici parce que vous avez utilisé ou essayé d'utiliser
la plateforme de simulation de systèmes réparables au sein de JMP.
Vous voudrez peut-être en apprendre un peu plus.
Tu pourrais être frustré parce qu'il y a des choses
que vous essayez de faire ce que vous ne pensiez pas pouvoir faire.
Alors ce que je vais couvrir aujourd'hui
sont des choses qui ne sont pas expliquées en profondeur dans la documentation,
des choses que j'ai apprises par essais et erreurs
qui ne sont pas dans la documentation,
et même des trucs que j'ai appris en discutant avec le développeur
à propos de la plateforme, des trucs que vous ne pourriez pas trouver
d'une autre manière.
Je vais supposer que vous avez été exposé à cette plateforme.
Je vais supposer que vous connaissez un peu l'analyse de fiabilité,
je n'ai donc pas besoin d'entrer dans les détails sur ce qu'est une configuration parallèle,
qu'est-ce que quelque chose qui est K sur N, et ainsi de suite.
J'ai donc un certain nombre d'exemples que je souhaite couvrir,
beaucoup de matériaux. Commençons.
Maintenant, avant d'examiner réellement
la plateforme de simulation de système réparable, permettez-moi juste de vous donner un aperçu.
J'espère que vous l'avez déjà utilisé, que vous le connaissez,
nous allons parler de trois composants différents
et les aspects de ces composants qui ne figurent pas dans la documentation
ou ne sont pas bien expliqués dans la documentation.
La première chose dont nous allons parler, ce sont les blocs.
Les blocs sont ce que j'utilise pour construire mes éléments de simulation de système réparable
comme Parallèle, K sur N, Veille.
Ainsi, pour chaque bloc, je peux associer un événement à ce bloc.
Voilà donc ces petits blocs oranges que l'on voit, et pour chaque bloc,
Je peux associer un ou plusieurs résultats ou actions.
Ce sont ces points bleus que nous voyons,
et cela va m'aider à construire ma simulation.
Par exemple, je souhaiterais peut-être savoir quand un blocage échoue
et quand ce bloc échoue, je pourrais vouloir réparer ce bloc,
et cette réparation pourrait prendre, disons, 40 heures.
C'est l'idée derrière la création de ces diagrammes RSS.
Commençons par parler de
certaines des propriétés générales des blocs.
Il y a six blocs différents dans un nœud,
ce qui me permet de relier les choses ensemble dans le diagramme.
Cinq de ces six blocs sont composites.
Ils ont été construits pour être constitués de deux sous-unités ou plus.
JMP vous permet de les utiliser avec une seule sous-unité.
Mais en réalité, le cas d’utilisation est qu’ils sont constitués de deux sous-unités ou plus.
Les événements et les actions sont appliqués à l'ensemble du bloc.
C'est donc un point important.
Les composants du bloc ne peuvent pas être traités individuellement,
sauf pour le bloc de veille.
Une seule distribution leur est attribuée.
Pris ensemble, ces deux puces signifient que des choses comme la réparation
ou la maintenance sur les sous-unités n'est pas possible
au sein de ces blocs composites.
Je dois attendre que tout le bloc échoue
avant de pouvoir faire quoi que ce soit avec ce bloc
avant de pouvoir réparer le bloc.
Si je veux des distributions différentes au sein du bloc,
Je ne peux pas faire ça non plus, à l'exception du Standby.
Et nous en parlerons dans un exemple que nous aurons un peu plus tard.
Sous-unités pour tous les blocs composites,
à l'exception des blocs Série, sont en parallèle.
Ce qui différencie ces différents blocs composites
sont le nombre de composants en cours d'exécution,
quand le bloc échoue et comment le bloc vieillit.
J'ai donc réalisé un petit tableau qui passe en revue tous les blocs composites
et comment ils diffèrent avec ces caractéristiques.
Pour tous les blocs composites, à l'exception du Standby,
tous les composants fonctionnent simultanément.
Avec un bloc composite, je peux choisir K parmi mes N unités à exécuter
puis les unités restantes seront des sauvegardes.
Alors, quand ces blocs échouent-ils ?
Évidemment, si vous avez une certaine expérience en matière de fiabilité, un bloc Série échoue
lorsqu'une unité tombe en panne.
Un bloc parallèle échoue lorsque toutes les unités échouent,
K sur N lorsque vous avez moins de K unités, et ainsi de suite.
Donc les choses auxquelles on peut s'attendre naturellement dans l'analyse de fiabilité,
La veille et le partage ont une autre méthode d'échec.
Avec l'unité de veille, il existe un mécanisme de commutation.
Il pourrait y avoir un seul commutateur pour tout le bloc
ou un commutateur pour chaque sauvegarde.
Le Standby peut échouer si j'ai un seul commutateur
lorsque ce commutateur échoue, ou si j'essaie d'utiliser
chacune de mes unités de sauvegarde
et le commutateur sur ces unités de sauvegarde échoue également.
Une défaillance du commutateur pourrait donc être une autre cause de la défaillance du bloc.
La même chose s’applique au partage du stress.
Cependant, avec Stress Sharing, je n’ai qu’un seul interrupteur.
La dernière caractéristique qui est différente
entre ces blocs composites, c'est la façon dont ils vieillissent.
Pour les trois premiers blocs, ils vieillissent de la même manière.
Toutes les sous-unités du bloc vieillissent de la même manière.
Pour la veille et le partage de stress, les sous-unités peuvent vieillir...
Pour Standby, ils peuvent vieillir différemment.
Pour le partage du stress, ils vieillissent définitivement différemment.
Pour la veille,
Je peux choisir une seule distribution pour mes unités opérationnelles.
Pour mes unités de secours,
Je peux choisir qu'ils ne vieillissent pas—c'est une attente froide—
ou je peux leur donner une distribution différente
quant à la façon dont ils vieillissent lorsqu'ils sont en mode veille
ou lorsqu'ils servent de sauvegardes.
Cela pourrait être la même chose, tout comme mes unités opérationnelles pourraient être quelque chose de différent.
Je peux donc choisir deux distributions différentes.
Le problème est, encore une fois,
comme pour tous ces blocs composites, j'obtiens une seule distribution
pour toutes mes unités opérationnelles, une seule distribution pour toutes mes sauvegardes.
Je ne peux pas mélanger et assortir.
Enfin, avec le partage du stress, le partage du stress fonctionne
un peu différemment.
Avec le partage du stress, le stress est réparti de manière égale entre les blocs.
Cependant, lorsqu'une des sous-unités tombe en panne,
des contraintes supplémentaires sont associées aux unités opérationnelles restantes.
Ainsi, le stress change d’échec en échec.
Nous en verrons un exemple dans un instant.
Maintenant, une des choses que vous avez peut-être trouvées,
ou tu réaliseras peut-être que parfois
vous souhaitez avoir un peu plus de flexibilité
et la façon dont je peux développer ma flexibilité est de pouvoir organiser mes blocs de base
ou mon bloc de base comme je le ferais avec un Parallèle ou un K sur N
comme l'un de mes blocs composites.
Les blocs de base peuvent être facilement disposés en série, en parallèle ou K sur N
plus difficile à faire avec les blocs Veille et Partage de stress
lorsque vous avez plus de deux unités.
J'ai un exemple dans un instant
qui montre une configuration de veille avec deux blocs de base.
Comment procéder relativement simplement.
Mais si je devais essayer d'étendre cela à trois blocs,
cela devient beaucoup plus difficile.
Pas impossible, juste très difficile à faire
parce que je devrais garder une trace de ce qui fonctionne, de ce qui ne fonctionne pas,
que se passe-t-il lorsque la panne se produit, etc.
La même chose vaut également pour le partage du stress.
Passons à notre premier exemple.
Pour notre premier exemple, nous allons examiner un arrangement de base K sur N.
Nous allons avoir cinq sous-unités.
Trois d’entre eux doivent être opérationnels.
Ils auront tous le Weibull avec un Alpha de 2 000 et un Bêta de 1.
Nous allons supposer que lorsqu'un bloc échoue
qu'il faut 40 heures pour le remplacer.
Nous allons mettre cet arrangement
en série avec un bloc composite K sur N.
Nous supposerons également que le bloc composite K sur N prend 40 heures
à remplacer, malgré le fait qu'il existe cinq sous-unités
dans ce bloc qui ont échoué.
Nous allons voir quelle différence cela fait
si je les traite comme des éléments individuels
ou comme article composite ?
Voici à quoi ressemblerait ma configuration en RSS.
Je l'ai gardé très simple.
Voici mes sous-unités relatives à mon K sur N.
Ce qui en fait un K sur N est dans le nœud.
Je peux préciser combien d'éléments entrants
il faut fonctionner.
Et ici, j'ai dit que j'en avais besoin de trois. C'est donc ce qui en fait un K sur N,
cet arrangement, K sur N.
Et je vais juste garder les choses très simples.
Le seul événement que je vais examiner est de savoir si le bloc échoue ou non,
la seule mesure que je vais prendre est de réparer comme neuf.
Allons-y et exécutons ceci.
Relativement rapide.
Je veux parler un peu du résultat
parce que ce qui est envoyé à la sortie et aux états
nous aidera lorsque nous commencerons à construire nos diagrammes à l’avenir.
Jetons simplement un coup d'œil à l'ordre des opérations
pour ce tout premier échec.
Nous voyons donc que l'unité Sub1 est en panne depuis 766 heures.
Le bloc est supprimé.
C'est donc important à noter car c'est l'un de mes événements potentiels.
Le bloc est donc supprimé, je lance le processus, je remplace le bloc.
Et après le remplacement du bloc, après les 40 heures que j'ai précisé
dans ma configuration, le système s'allume automatiquement.
C'est donc un autre point important.
Nous allons nous heurter à la situation
où pour certains de mes événements, le système ne reçoit pas
allumé automatiquement, et je vais parler de lesquels il s'agit.
Ce que nous devrons faire dans ces cas
est en fait d'allumer le système, ou dans certains cas, lorsque le bloc
ne s'allume pas automatiquement, allumez le bloc manuellement.
Ici, nous avons un échec Sub3 et vous voyez une série d'événements similaires,
Sub2 échoue, etc. Voyons ce qui se passe
quand le système tombe en panne.
Et nous savons que cela se produit avec certitude lorsque K sur N échoue.
D'accord, voici donc le premier cas où le système échoue.
Encore une fois, très similaire en ce qui concerne la plupart des opérations,
mais vous remarquerez que cela coupe le système.
Remarquez qu'il a éteint le système, donc je peux éteindre le système.
Il désactive tous les blocs du système.
Encore une fois, quelque chose d'important à garder à l'esprit,
parce qu'il y aura des cas où nous aurons besoin de savoir
si un bloc est activé ou désactivé.
Si nous devons ou non activer un blocage manuellement.
C'est donc parti pour le remplacement.
Une fois le remplacement terminé,
tous les blocs sont activés automatiquement.
Et encore une fois avec ce remplacement, avec du nouveau,
l'extinction et l'allumage se font automatiquement.
Je n'ai donc pas à m'inquiéter pour ça.
Finalement, j'ai terminé mon remplacement K out N et j'ai terminé jusqu'au prochain échec.
Relativement simple.
Si je voulais voir comment mon système a fonctionné
Je vais juste lancer mon Result Explorer.
Par défaut, je ne verrai pas les informations au niveau des composants.
Si je veux des informations au niveau des composants, je dois remonter au point d'accès
et choisis si je veux une combinaison,
Je vais choisir mon temps d'arrêt par composant.
Maintenant, ce qu'il faut garder à l'esprit avec cette organisation,
c'est juste pour me dire
le temps d'arrêt du système associé à mes composants.
Cela me dit donc combien de fois K sur N a mis le système hors service.
Pour chacun d'entre eux,
cela correspondait au moment où cette sous-unité a mis le système hors service.
Donc si on y réfléchit, ça correspond aux époques
Quand la sous-unité a été la dernière de mes cinq unités à tomber en panne,
parce que c'est la seule fois où le système va tomber en panne
c'est quand toutes ces cinq sous-unités tombent en panne.
Maintenant, si je veux regarder ma distribution au niveau des composants,
cela ne me dit que quand cela fait tomber le système.
Mais disons que je m'intéresse à la fréquence à laquelle Sub1 était en panne,
à quelle fréquence Sub2 était en panne et ainsi de suite.
Le point chaud, je peux regarder cette estimation de point
pour la disponibilité des composants.
Et si je fais défiler vers le bas, par exemple, pour Sub1,
cela me donne mes informations de distribution
pour le composant lui-même.
Z inclut non seulement les moments où la sous-unité 1 a mis le système hors service,
mais quand la sous-unité 1 s'est effondrée d'elle-même.
Le moyen le plus simple de plonger dans les distributions individuelles de tous mes sous-composants.
Passons à certaines de ces actions et événements
et certaines des propriétés particulières associées à celles-ci.
Nous commencerons par les événements.
Non mentionné dans la documentation
mais Inservice n'est disponible que pour les blocs Basic.
Alors pour rappel, Inservice est basé sur l'âge du bloc
et non l'âge de l'époque de la simulation.
Ainsi, par exemple, si je veux entretenir quelque chose
après 100 heures d'utilisation, j'utiliserais un Inservice.
Sinon, je pourrais utiliser simplement un événement programmé.
Un événement programmé serait desservi une fois par semaine,
mais Inservice n'est disponible que pour mon bloc Basic.
Alors me dit si je veux utiliser Inservice,
Je vais devoir construire ces blocs de base.
Initialisation, échec de bloc et système en panne
ne peut être utilisé qu’une seule fois pour chaque bloc.
Donc ce que vous verrez, c'est quand vous les utiliserez,
ils disparaissent de votre palette d'événements, donc ils n'apparaîtront plus.
Vous ne pouvez donc les utiliser qu’une seule fois.
Parlons d'actions.
Il y a 13 actions que je peux utiliser.
Install Used, Change Distribution et If ne peuvent être utilisés qu'avec des blocs de base.
La réparation minimale ne peut être utilisée qu'avec Basic et Series.
Cela nous laisse donc neuf actions que je peux utiliser pour n'importe lequel des blocs.
Il s'agit donc d'allumer et d'éteindre un bloc, d'allumer et d'éteindre le système,
Remplacer par un nouveau, installer un nouveau, supprimer un bloc, inspecter l'échec,
et Calendrier. Donc ce sont les neuf
que n'importe quel bloc, qu'il soit de base ou composite, peut utiliser.
Il n'y a pas de limite au nombre de fois qu'une action peut être utilisée sur un bloc donné.
J'ai donc un exemple où j'ai utilisé Turn Off Block plus d'une fois.
La raison en est que
ce que je veux faire après avoir allumé ou quand j'allume le bloc peut différer
en fonction du moment où le bloc est activé.
Et encore une fois, nous en verrons un exemple dans un instant.
Les actions ne peuvent être connectées qu'à d'autres actions.
En fait, les événements ne peuvent être liés qu’à des actions.
Je ne peux donc pas connecter un événement ou une action à un bloc ou à un autre événement.
Cependant, je suis illimité quant au nombre d’actions que je peux enchaîner.
Quelques propriétés spécifiques.
L'initialisation n'a lieu qu'une seule fois, et c'est au tout début
de l’exécution de la simulation.
Nous allons avoir un exemple où cela fait une différence,
où je désactive un bloc lors d'une initialisation,
mais lorsque le système revient en ligne, ce blocage est réactivé.
Je vais donc devoir m'assurer de désactiver cela manuellement.
L'initialisation n'a donc lieu qu'au début.
Le système est en panne se produit pour chaque bloc,
quel que soit le bloc qui a fait tomber le système.
Je peux donc l'utiliser en tant qu'auditeur pour voir...
Par exemple, si le système tombe en panne,
Je souhaiterais peut-être effectuer une maintenance sur le bloc même si le bloc
était en cours d'exécution, peut-être juste pour le relancer
pour qu'il soit proche du neuf ou pour le remettre comme neuf.
Ainsi, un système en panne se produira quel que soit le bloc qui l'a provoqué.
Ensuite à propos des actions,
Activer le système active tous les blocs disponibles.
Maintenant, par chaque bloc, je veux dire tout ce qui n'est pas déjà en panne
en raison d'une panne ou d'une panne programmée.
Pour que je puisse programmer quelque chose en panne
soit en utilisant cet événement planifié, soit en utilisant l'action planifiée.
Allumer le système va activer tous mes blocs.
Les blocs doivent être activés manuellement
après une nouvelle installation, une installation utilisée ou une modification de la distribution.
Ce sont quelques-uns de ces cas où le système ne s'allume pas,
le bloc ne s'allume pas automatiquement.
C'est pourquoi je pourrais vouloir utiliser,
par exemple, installez new au lieu de Remplacer par New.
Installer nouveau me permet de faire des choses avant de rallumer le système.
Cela me donne cette chance d'effectuer d'autres opérations
ou d'autres actions avant d'allumer mon système.
Activer le blocage n'allume pas le système si le blocage a été désactivé manuellement.
Comme nous l'avons vu dans le résultat,
comme vous l'avez peut-être remarqué dans le résultat, quel que soit le système allumé,
vous pourriez obtenir un événement d'activation du système.
Cela ne fait pas de mal d'allumer un système si celui-ci est déjà allumé.
Ce que je dis, c'est qu'en cas de doute, ajoutez un système d'activation
à votre chaîne d'événements pour vous assurer que le système est activé.
À propos, peu importe que le bloc soit activé en premier
ou le système est allumé en premier.
Les deux fonctionnent de la même manière.
Très bien, passons à notre deuxième exemple.
Ce que nous allons faire, c'est construire un bloc de base
dans un arrangement de veille.
Nous allons avoir une unité principale et une unité de secours.
On va faire un démarrage à froid,
ce qui signifie que l'unité de secours, l'unité de secours, ne vieillit pas.
Cependant, le démarrage de l'unité prendra 30 minutes.
Quelque chose que je ne peux pas faire avec la veille composite.
Huit heures de maintenance sur la sauvegarde sont effectuées après contrôle
est renvoyé à l’unité principale.
Nous allons examiner deux situations de commutation différentes.
Nous allons en fait examiner un interrupteur infaillible et nous allons
pour regarder un commutateur où nous avons une fiabilité de 90%.
Pour tous mes blocs, je vais supposer Exponential(500).
Je vais prendre huit heures pour réparer ou entretenir.
Les blocs défaillants seront remplacés par de nouveaux.
Comme l'exemple précédent, nous allons regarder les blocs de base
dans cet agencement en série avec un bloc de secours avec la même configuration,
évidemment, à l'exception de ce temps de démarrage de 30 minutes,
ce que je ne peux pas faire.
Nous allons jeter un coup d'oeil.
Voici notre arrangement de base.
J'ai mon unité de secours, mon unité principale, mon unité de secours et pour chacune d'elles
J'ai associé un événement d'échec et un remplacement par un nouveau.
C'est en quelque sorte l'essentiel de ce avec quoi je pourrais commencer.
Je ne sais pas si je l'ai déjà souligné lorsque nous regardions le résultat,
mais c'est utile lorsque j'ajoute un événement, j'ajoute une action pour lui donner un nom unique
parce que ce sont les noms qui apparaissent dans ma sortie.
Très bien, commençons par une unité de secours.
Lorsque mon système sera mis en ligne au temps zéro, tout sera allumé.
Je veux m'assurer qu'au temps zéro, cette unité de sauvegarde est éteinte.
La façon dont je vais procéder est d'utiliser l'initialisation.
Vous remarquerez que lorsque j'ai utilisé l'initialisation,
c'est disparu.
La prochaine chose que je veux faire est d'éteindre le bloc.
Maintenant, si vous avez déjà utilisé RSS,
vous vous souviendrez que lorsque j'essaie d'ajouter une action,
cela va empiler ces actions les unes sur les autres.
Parfois, ce n'est pas le meilleur endroit pour eux.
Ce que vous pourriez faire chaque fois que vous avez une action sur laquelle travailler,
Je peux sélectionner l'action, cliquer et maintenir ce signe plus
puis faites simplement glisser le plus.
Maintenant, je peux ajouter mon action.
Dans ce cas, je souhaite désactiver le blocage.
Maintenant, je ne veux pas que le bloc Désactiver soit associé à cela, remplacez-le par Nouveau.
Ce que je vais faire pour éviter que cela ne se produise, c'est simplement de supprimer la flèche.
Je peux désormais me connecter à l'événement que je souhaite.
L’avantage de faire cela est que je peux désormais déplacer ce bloc où je veux.
J'ai beaucoup plus de flexibilité avec le fonctionnement de ce bloc.
L'autre chose que je vais faire, c'est que je veux absolument les étiqueter
donc je sais que lorsque je regarderai mon tableau de résultats, je saurai ce qui se passe.
C'est Désactiver le blocage...
Appelons simplement cela désactiver la sauvegarde au début.
Je vais donner à chacun de mes événements, à chacune de mes actions un nom unique
donc je sais quand ils se produisent.
Cela désactive ma sauvegarde au début.
La prochaine chose que je vais vouloir faire, c'est quand l'unité principale tombe en panne,
Je vais vouloir allumer l'unité de secours.
Maintenant, encore une fois, plutôt que de sélectionner l'unité de sauvegarde et de dire Activer le blocage,
Je vais choisir mon Turn on Block de manière interactive.
Je vais supprimer ma connexion ici pour pouvoir la déplacer.
Je vais déplacer un peu les choses.
Je vais déplacer ça ici.
Encore une fois, je veux nommer cela de sorte que si je reviens à ce diagramme
dans quelques jours, je sais à quoi cette action est associée.
Nous appellerons cela l'activation de la sauvegarde à partir du principal.
Une autre chose qui est mentionnée dans la documentation,
mais je ne sais pas avec quelle force, mais je peux me connecter,
dans ce cas, je connecte un événement d'un bloc à une action
dans un autre bloc.
Je peux certainement le faire.
Maintenant, comme je l'ai mentionné plus tôt, cela activera le bloc
parce que ce bloc a été désactivé manuellement,
Je vais également devoir allumer le système.
Allumez le système.
Encore une fois, je veux probablement étiqueter cela,
Je dirai : allumez le système à partir de la sauvegarde, etc.
Maintenant, la seule autre chose que je dois ajouter à mon diagramme est que
quand mon principal revient en ligne, je veux désactiver ma sauvegarde,
faire la maintenance de ma sauvegarde.
Maintenant, je pourrais probablement...
Eh bien, commençons par désactiver la sauvegarde, désactiver le blocage.
Supprimez ça.
Nous appellerons ça.
J'ai dû choisir d'allumer, j'ai désactivé le blocage.
Essayons à nouveau.
Désactivez Bloquer et étiquetez-le, désactivez la sauvegarde à partir du principal.
C'est là que mon principal est mis en ligne.
Là, j'ai désactivé ma sauvegarde.
Je souhaite y effectuer une maintenance.
La façon dont je vais procéder est de simplement remplacer par New.
D'accord, nous appellerons simplement cela la maintenance préventive.
Je pense avoir dit que cette maintenance préventive allait
ça fait huit heures que ça prend.
Maintenant encore, je dois me souvenir
que Remplacer par Nouveau démarre automatiquement le bloc.
Ce que je vais devoir faire maintenant, c'est éteindre le bloc.
Maintenant, en y réfléchissant un peu plus en détail,
J'aurais probablement pu passer directement du nouveau en ligne
pour faire l'entretien.
Car une fois que je démarre la maintenance sur ma sauvegarde, la sauvegarde cesse de fonctionner.
Puis une fois que j'ai fini ma maintenance,
éteindre le bloc.
Ce bloc ne fait pas de mal, mais il est redondant.
Alors débarrassons-nous-en.
Ce serait ma configuration.
J'aime toujours courir pour vérifier si les choses fonctionnent
dans le bon ordre et je générerai ma sortie.
Dans ce cas, je ne l'ai configuré que pour faire une seule simulation.
Je devrais peut-être en prendre quelques-uns
de simulations en fonction de la fiabilité associée à mes unités.
Voici les principaux échecs, le système s'arrête,
le bloc de veille est éteint, mis en place un nouveau principal,
activez la sauvegarde pour le principal.
Si nous regardons la colonne des prédateurs, c'est à mon tour d'activer la sauvegarde pour le principal.
Activez le système à partir de la sauvegarde, activez le blocage par système.
Encore une fois, j'aime les parcourir une fois que je les ai construits pour m'assurer
les choses se passent dans le bon ordre.
Le système est activé.
Voilà, la nouvelle conduite principale est installée.
J'allume mon système,
encore une fois, c'est déjà allumé, mais ce n'est pas grave, ça ne fait pas de mal.
Nouveau principal Remplacer par Nouveau.
C'est le bloc, la sauvegarde étant tournée
pour obtenir un MP et ainsi de suite.
Cette sauvegarde devrait être désactivée.
Encore une fois, j'aime les utiliser juste pour vérifier
pour que les choses fonctionnent correctement.
C'est la configuration sans le commutateur.
Ajouter le commutateur est relativement simple.
Là où nous mettrions cela, nous mettrions cela
entre la panne principale et le démarrage de la sauvegarde
et c'est à cela que servent les blocs if.
Permettez-moi de me débarrasser de cette connexion.
Peu importe de quel bloc cela vient
et je ne voulais pas le mettre là.
Laisse-moi partir de...On y va.
J'ai une sauvegarde juste au cas où quelque chose comme ça se produirait.
On y va.
Ma sauvegarde est activée.
C’est là mon principal défaut.
Nous allons nous en débarrasser.
Je veux probablement ajouter mon bloc if pour pouvoir le faire flotter n'importe où.
Je vais juste en prendre un et nous ajouterons un if.
Supprimez la connexion.
Relions cela.
Maintenant, la façon dont je configurerais mon if,
la façon dont if fonctionne est qu'il évalue ce qu'il y a dans la boîte de condition if.
Si c'est vrai, si cela donne un résultat, alors vous continuez.
S'il est évalué à zéro, vous arrêtez.
Ce que je peux dire, c'est si... Je n'ai pas besoin du si là,
Je vais dire que l'uniforme aléatoire est inférieur à 0,9.
Quand c’est vrai, la chaîne continuera, sinon elle s’arrêtera là.
C'est ça.
C'est aussi simple que cela de mettre cette instruction if.
Encore une fois, je veux probablement aussi étiqueter cela.
Donc, si le changement réussit ou quelque chose comme ça.
À ce stade, le seul inconvénient est la suivante : que se passerait-il si le commutateur tombait en panne ?
Eh bien, le commutateur a échoué, il va falloir attendre que le principal revienne en ligne.
Main revient en ligne, il essaie de désactiver ma sauvegarde.
Cela ne fait pas de mal d'essayer de désactiver quelque chose qui est déjà éteint.
Mais la chose que je ne voudrais peut-être pas faire
est-ce que je ne voudrais peut-être pas faire la maintenance si la sauvegarde n'était pas utilisée.
Dans un exemple ultérieur, nous verrons comment contourner ce problème,
comment examiner le système et savoir si cette sauvegarde est en cours d'exécution ?
S'il ne fonctionne pas, oui, effectuez la maintenance.
S'il est en cours d'exécution, vous n'avez pas besoin de maintenance.
Passons à l'exemple suivant.
Dans ce cas, j'ai deux pompes qui fonctionnent en parallèle avec une maintenance préventive
effectué toutes les deux semaines et dure huit heures.
Les PM sont échelonnés d'une semaine pour éviter d'avoir les deux pompes en panne
en même temps.
Si une pompe tombe en panne, une réparation minimale, prenant quatre heures, est effectuée.
Dans ce cas, la simulation est exécutée sur une durée d'un an.
Commençons par le strict minimum.
Voici mes pompes avec les pannes et les remplacements des pompes.
Comment mettre en place l'attente une semaine avant de démarrer les MP ?
Comme pour le dernier exemple, je vais commencer par l'initialisation.
Ce que je vais dire, c'est d'attendre une semaine.
Comment dire attendre une semaine ?
Eh bien, ce que je vais faire, c'est utiliser l'action de planification.
Je vais faire ce que j'ai fait dans le passé.
Nous allons établir le planning, supprimer ma connexion.
J'ai un certain nombre d'options différentes avec le calendrier.
Je veux seulement que cela arrive une fois. Je veux que ça arrive dès le début
il est donc connecté à mon événement d'initialisation.
Nous allons appeler cette attente une semaine.
Je veux seulement que cela arrive une fois.
Je veux que cela prenne 168 heures.
C'est parce que ma simulation est configurée en quelques heures.
Ce que ça fait, c'est qu'au démarrage, j'attends une semaine
puis exécute toute action à laquelle je me connecte ici.
Quelle est l'action que je vais connecter ?
Eh bien, je vais à nouveau utiliser le calendrier.
Ce que cela va être, c'est que ce sera du PM sur la pompe 2.
Je vais laisser mon occurrence maximale vide.
Il le fait donc jusqu'à la fin de la simulation.
Le temps de réalisation sera de 168x2 donc 336.
Ce qui se passe maintenant, c'est qu'après cette première semaine, toutes les 336 heures,
Je vais pouvoir effectuer une autre opération.
Cette opération propose différentes manières de procéder.
Nous allons supposer qu'il est PM [inaudible 00:37:03].
Nous allons donc dire Remplacer par Nouveau.
Je peux dire ici, remplacez la pompe B.
Maintenant, l'une des choses auxquelles vous pensez peut-être est que
que se passe-t-il si je fais ma maintenance préventive
et tout est décalé mais pour une raison quelconque, la pompe A est en panne,
il aurait pu y avoir un échec.
Je ne démonterais pas forcément ma pompe B
pour la maintenance préventive.
Faites-le et démontez le système. Ce que nous allons utiliser, c'est que nous allons
pour utiliser une variable cachée appelée contexte de simulation.
Le contexte de simulation est la façon dont je peux examiner mon système.
Ce que nous allons faire, c'est mettre le contexte de simulation,
nous le placerons entre ma maintenance préventive programmée et ma maintenance préventive réelle.
Faisons cela.
Débarrassons-nous de cela et nous l'implémenterons avec un if.
Laissez-moi me connecter et nous appellerons ceci, si la pompe A fonctionne,
maintenant la question est, comment savoir si la pompe A fonctionne ?
Eh bien, dans ma condition if, je dois spécifier la variable cachée
c'est associé à la pompe A... Qu'il soit actif ou non.
La façon dont je procéderais est le contexte de simulation
et le cas n'a pas d'importance.
Contexte de simulation et les variables,
les variables système sont stockées en tant qu'associées du tableau.
C'est ce qu'on appelle l'état de la pompe A.
Maintenant, ce que j'ai trouvé, c'est que
cette partie particulière de la boîte de dialogue n'est pas aussi flexible.
Si j'ai quelque chose de plus complexe que je veux construire,
alors je le fais généralement dans une fenêtre de script, puis je le copie puis je le colle
dans cette fenêtre.
Mais c'est relativement petit et nous allons simplement continuer et taper.
Nous allons dire que c'est actif.
C'est ce que j'utiliserais.
Maintenant, comment ai-je su que c'était ce que je devais utiliser ?
Eh bien, il s'avère que c'est une condition et un peu
plus tard, quand nous parlerons du partage du stress,
cela agit comme un script.
Ce que je peux faire et ce que j'ai souvent fait
est placé dans une déclaration imprimée, comment puis-je savoir ce qui est disponible pour moi ?
Mettons ici une déclaration imprimée
et nous dirons contexte de simulation d'impression, d'accord.
La seule chose dont nous devons être sûrs
est-ce que l'instruction if, la dernière instruction de cette condition if évalue le vrai.
Juste pour te montrer ce qui se passe
quand je fais ça, allons-y et exécutons ceci.
Je vais faire ça juste pour te donner une idée
de ce qui est imprimé dans le journal.
Laisse-moi aller chercher mon journal et c'est fini sur l'un de mes autres…
C'est parti, voici mon journal
et c'est reparti.
C'est ce qui a été imprimé dans le journal.
Cela me donne des informations sur toutes les variables disponibles
dans un contexte de simulation pour ce diagramme particulier.
Si j'avais mis plus de blocs, plus d'actions, plus d'événements
alors ceux-ci apparaîtraient, les informations à ce sujet apparaîtraient également.
Mais c'est une bonne façon de le dire
ce qu'il y a dans mon système et quelles sont les variables auxquelles j'ai accès.
La chose importante à retenir ici est
Je peux lire ceci, mais je ne peux pas répondre à cette variable particulière.
Je n'ai pas cette option pour changer les choses dans ma simulation,
mais je peux utiliser cette information.
Pour revenir à notre dernier exemple, ce que j'aurais pu faire
c'est que j'aurais pu y mettre une instruction if
et j'ai dit que si ma sauvegarde était active,
eh bien, baissez-le, faites l'entretien.
D'accord.
Maintenant, pour gagner du temps, je vais passer à autre chose
à ma dernière information que je souhaite partager avec vous.
Au fait, j'aurai un journal à disposition,
devrait avoir un article disponible,
J'aurai d'autres exemples que je n'ai pas eu le temps d'aborder.
Vous verrez quelques autres actions
nous n'avons pas eu l'occasion de voir comment ils sont mis en œuvre
et peut-être d'autres choses
ce n’est peut-être pas très simple.
Le partage de stress personnalisé est un peu inhabituel dans le sens où, par défaut,
le stress est partagé également entre les sous-unités.
Il est implémenté en modifiant la façon dont ce bloc vieillit
et ne modifiant pas explicitement la distribution.
Quand je n'ai pas de partage de stress, disons que j'ai n sous-unités en parallèle,
disons que le premier échoue au premier instant, le second au deuxième instant, et ainsi de suite.
Avec le partage du stress, la façon dont je vieillis le bloc
est-ce que la première défaillance se produit à t fois n,
fois le nombre d’unités de travail.
Le second vieillit le bloc de n moins un supplémentaire
fois la différence entre mon premier et mon deuxième échec.
Le troisième n moins deux fois la différence entre
le troisième, le deuxième échec et ainsi de suite.
C'est ainsi que les blocs vieillissent.
Ce sont les informations qui sont transmises à cette fonction personnalisée.
Quand j'essaie d'intégrer cela dans mon partage de stress,
ok, alors laissez-moi partager avec vous ce dernier exemple sur la façon dont cela est configuré.
Laissez-moi trouver mon exemple.
D'accord, j'ai ici trois partages de stress différents.
Il y a mon partage de stress de base, donc je l'ai configuré comme base.
Voici ma coutume.
C'est de cette fin dont je parle.
Vous saurez qu'il est intégré dans cette fonction de journal.
C'est fait de cette façon pour que le vieillissement du bloc corresponde
avec les distributions que je peux utiliser pour mon bloc de partage de stress personnalisé.
Ce que je fais, c'est penser aux choses en fonction de mon explication
que la première unité vieillit à un certain multiplicateur de temps,
le second à quelques multiplicateurs fois la différence entre
mes premier et deuxième échecs, et ainsi de suite.C'est comme ça que je pense
à propos de toutes ces choses.Par exemple, disons que je souhaite configurer,
eh bien, avant d'y aller, permettez-moi juste de dire brièvement,
comme avec le bloc if, je peux mettre des instructions d'impression ici.
Si je devais mettre ici une déclaration imprimée,
vous remarquerez que cela est exécuté avant le démarrage du système,
donc ça va en imprimer cinq et ça va en imprimer cinq
car dans ce cas le bloc a cinq unités.
Je vais en imprimer cinq quand le premier échoue,
ça va rentrer dans la fonction print four,
et ainsi de suite, ainsi de suite.
Disons que je voulais configurer cela comme un échec personnalisé où le bloc
vieillit 10 fois, pas 5 fois, mais 10 fois plus vite,
le deuxième a cinq ans, le troisième a trois ans.
Le deuxième vieillit à un an,
et le dernier est trop stressé et vieillit deux fois plus vite.
Ce que je pourrais faire, c'est
encore une fois, mettons cela ici.
Permettez-moi d'ajouter un peu d'espace
et agrandir un peu ma boîte.
Je pourrais mettre quelque chose comme,
encore une fois, je veux mettre ce journal, ce journal doit être là,
log et je dirais quelque chose comme choisir.
Ce que choisit fait en fonction de n, ça reviendra,
voyons, quand il y a une unité, je veux qu'elle renvoie une moitié, une avec deux unités,
disons 2,5 avec 3 unités,
5 avec 4 unités, puis enfin 10.
C'est ainsi que je créerais mon partage de stress personnalisé.
Je ne suis pas limité à cette fonction de choix.
Ici, j'ai dans cet exemple particulier,
J'utilise une fonction.
Ok, encore une fois, ce qui est important ici
est que tout cela est intégré dans cette fonction de journalisation afin que le vieillissement
du bloc et les distributions peuvent correspondre.
D'accord, malheureusement, c'est tout ce que j'ai le temps de couvrir aujourd'hui.
J'aurais aimé avoir plus de temps. Il y a certainement beaucoup
d'autres choses dont nous pourrions parler.
Ceux-ci seront dans les documents que je vous ai fournis,
et j'aimerais entendre vos commentaires
ainsi que vos questions et commentaires.
Encore une fois, merci d'avoir pris le temps. Regarde ça.
J'espère que cela est vraiment bénéfique. Merci.
