< |
| <img title="" src=".\files\img\Logo%20LIGERON.png" alt="SOM Ligeron" width="150"> | Sylvain BRETON <br />  |
|Licence |
| ------------- |
| [Attribution - Utilisation non commerciale 4.0 International (CC BY-NC 4.0)](https://creativecommons.org/licenses/by-nc/4.0/deed.fr) |
## Sommaire
1. [Généralités](#generalite)
2. [Installation](#installation)
3. [Modèles de fiabilité](#modeles)
4. [Utilisation de l'interface](#interface)
5. [Création d'un modèle](#modele)
6. [Réalisation des calculs de probabilité](#calculs)
7. [Réalisation d'une analyse de testabilité](#testabilite)
8. [Fonctionnalités avancées](#avance)
## Généralités <a name="generalite"></a>
System-Analyst est un logiciel métier dédié aux études de sûreté de fonctionnement. L'ambition de System-Analyst est de proposer un outil permettant, au travers d'un modèle unique partagé et documenté, de réaliser les études suivantes:
- Analyse fonctionnelle (AF);
- Analyse des modes de défaillance, de leurs effets et de leurs criticités (AMDEC);
- Analyse par arbres de défaillances (ADD);
- Analyse de testabilité;
- Analyse de disponibilité et dimensionnement de stocks.
## Installation <a name="installation"></a>
### Généralités
L'applicatif System-Analyst se décompose en deux grandes parties:
1. System-Analyst;
2. L'applicatif Arbre-Analyst.
### Téléchargements
#### 1. System-Analyst
Pour télécharger System-Analyst, rendez-vous à l'adresse suivante: http://www.system-analyst.fr/ et sélectionnez le système d'exploitation qui correspond à votre besoin.
System-Analyst se présente sous la forme d'une archive ZIP que vous pourrez extraire dans le répertoire souhaité.
#### 2. Arbre-Analyst
##### Installation
Arbre-Analyst est un applicatif d'édition d'arbres de défaillance. Il vous permettra d'afficher et de manipuler les arbres de défaillance générés par System-Analyst.
Cet applicatif est librement téléchargeable depuis le site Internet du projet https://www.arbre-analyste.fr/
##### Configuration
Il est possible de configurer System-Analyst pour que les arbres générés soient ouverts directement dans Arbre-Analyst. Pour cela, il faut se rendre dans la fenêtre de configuration de System-Analyst et renseigner le chemin d'accès à l'exécutable "Arbre-Analyst.exe" en double-cliquant dessus.
<img src="files/img/sa_window_conf.png">
## Modèles de fiabilité <a name="modeles"></a>
Les lois de probabilités de défaillances des événements élémentaires sont décrites ci-après avec leurs paramètres de fiabilité.
Paramètres généraux:
- γ : Probabilité à la sollicitation
- λ : Taux de défaillance
- μ : Taux de réparation (et son inverse le temps de réparation, MTTR)
- t : Temps de mission
### La loi « Constante »
La loi « Constante » correspond aux éléments dont la probabilité de défaillance est constante et s'exprime par :
<img title="" src=".\files\img\Formule_constante.png" alt="Formule_constante.png" data-align="center" width="92">
### La loi « Exponential »
La loi « Exponentielle » correspond aux éléments non réparables, la probabilité de défaillance s'exprime par la formule :
<img title="" src="./files/img/Formule_Expo.png" alt="Formule_Expo.png" data-align="center">
### La loi « GLM »
La loi « GLM » correspond aux éléments réparables, la probabilité de défaillance s’exprime par :
<img title="" src=".\files\img\Formule_GLM.png" alt="Formule_GLM.png" data-align="center" width="385">
### La loi « Périodic test »
Cette loi permet de représenter un composant qui tombe en panne selon une loi de distribution exponentielle et dont on constate la panne lors d'un test périodique. La réparabilité du composant par le biais du paramètre μ.
<img title="" src=".\files\img\Formule_périodic.png" alt="Formule_périodic.png" width="493" data-align="center">
- τ : Intervalle entre 2 tests consécutifs
- θ : date du premier test
### La loi « Reparable»
La loi « Réparable (TT) » correspond aux éléments réparables, la probabilité de défaillance à l'instant t s’exprime par :
<img title="" src="./files/img/Formule_réparable.png" alt="Formule_réparable.png" width="478" data-align="center">
## Utilisation de l'interface <a name="interface"></a>
### Fenêtre principale
#### Vue d'ensemble
La fenêtre principale est constituée des éléments suivants:
<img title="" src="./files/img/sa_window_main_overview.png" alt="">
1. Une barre de menu principal ;
2. Une barre d'icone à accès "rapide" ;
3. Une zone de sélection d'outils d'édition ;
4. Une zone d'édition des paramètres de l'élément "courant" sélectionné ;
5. Une zone de dessin ;
6. Une arborescence des éléments projets.
#### Description des éléments
##### 1. Menu principal
<img src="./files/img/main_menu.png">
L'onglet <u>Fichier</u> permet:
- de créer un **nouveau** projet ;
- d'**ouvrir** un projet existant ;
- d'**enregistrer** le projet en cours ;
- d'**exporter le code AltaRica** (d'une fonction locale ou de l'ensemble du système) ;
- d'**importer depuis Capella** ;
d'**exporter graphiquement** le projet actuel ;
<img title="" src="./files/img/file_menu.png" alt="" data-align="inline">
L'onglet <u>Edition</u> permet d'utiliser les raccourcis clavier via l'onglet:
- **copier** un élément ;
- **couper** un élément ;
- **coller** cet élément ;
- **annuler** une action ;
- **refaire** la dernière action annulée ;
- **tout sélectionner** ;
- **zoomer** ;
- **dézoomer** ;
- **annuler le zoom** ;
- **rechercher** ;
- **éditer la configuration** ;
<img title="" src="./files/img/edition_menu.png" alt="">
L'onglet <u>Données</u> permet:
- de voir et créer des **paramètres nommés** ;
- d'ajouter ou supprimer des **effets finaux** ;
- d'ajouter ou supprimer des **modes de défaillances** ;
- de voir les **paramètres logistiques** ;
- d'**éditer des matrices AMDEC** ;
- d'**éditer le projet sous Excel** ;
- voir la **bibliothèque** ;
- **importer depuis Excel** ;
- d'exécuter des **tâches automatisées**, comme *rechercher et corriger les boucles fermées problématiques*, *créateurs de liens*, *auto-répartition des taux de défaillances* ou *création de modes de défaillance*.
<img title="" src="./files/img/datas_menu.png" alt="">
L'onglet <u>Calculer</u> permet de choisir si l'on veut effectuer l'action sur une *fonction locale* ou sur le *système globale*:
- de lancer **un simulation pas à pas**
- de lancer la création d'une **AMDEC**
- de lancer l'**analyse de testabilité**
<img title="" src="./files/img/compute_menu.png" alt="">
L'onglet <u>Modules complémentaires</u> permet de lancer des modules complémentaires qui auront été installés.
L'onglet <u>Aide</u> nous permet:
- d'avoir accès à l'**Aide en ligne** qui redirige sur une documentation sur un navigateur web
- d'en savoir un peu plus **A propos de System-Analyst**
##### 2. Barre d'accès rapide
Certaines fonctionnalités des différents onglets du menu principal sont disponibles dans la barre d'accès rapide, comme par exemple **Nouveau**, **Ouvrir**, **Enregistrer**, **Enregistrer sous**, **Copier**, **Coller**, **Tout sélectionner**, **Configuration**, **Zoomer**, **Dézoomer** ou encore **Masquer UI** qui permet de cacher / d'afficher les panneaux de droite et/ou de gauche.
##### 3. Zone de sélection d'outils d'édition
Dans cette zone, différents outils sont proposés afin de créer ou de modifier un modèle. Ces différents outils sont:
-  **Sélection** qui permet de sélectionner un élément, le déplacer
-  **Créer un lien** entre des éléments
-  **Supprimer** un élément
-  **Créer une fonction**
-  **Créer un évènement**
-  **Créer une porte logique**
-  **Créer une porte de dérivation**
-  **Créer une porte pour boucle fermé**
-  **Créer un évènement de mitigation**
-  **Créer un observateur**
-  **Créer un test**
-  **Créer une entrée**
-  **Créer une sortie**
-  **Créer un multiplexage**
-  **Créer un rectangle**
-  **Créer un texte**
-  **Aligner verticalement** les éléments
-  **Aligner horizontalement** les éléments
-  **Copier la couleur** d'un élément
-  **Copier l'apparence** d'un élément
##### 4. Zone d'édition des paramétres de l'élement sélectionné
Cete zone d'édition permet de modifier différents paramètres d'un évènement tels que : le **Mode de défaillance**, son **Effet local**, son aspect, etc...
<img title="" src="./files/img/one_element.png" alt="" data-align="center"><img title="" src="./files/img/properties_one_element.png" alt="" data-align="center">
##### 5. Zone de dessin
La zone de dessin permet de visualiser les éléments ajoutés, d'interagir avec ceux-ci, les configurer, les relier entre eux afin de créer un modèle de calcul.
##### 6. Arborescence du projet
L'arborescence du projet commence par le système en entier.
<img title="" src="./files/img/arborescence_1.png" alt=""> <img title="" src="./files/img/all_model.png" alt="">
Il est ensuite possible d'accéder par exemple au modèle Hydraulique.
<img title="" src="./files/img/arborescence_2.png" alt="" data-align="center"><img title="" src="./files/img/hydraulic_model.png" alt="" data-align="center">
Pour finalement pouvoir accéder à un élément particulier, par exemple A1.
<img title="" src="./files/img/arborescence_3.png" alt="" data-align="center">
<img title="" src="./files/img/A1_element.png" alt="" data-align="center">
## Créer un modèle <a name="modele"></a>
### Saisir des fonctions
Ouvrez **un nouveau projet**, et créez une fonction. Pour saisir les différentes **Fonctions**, il suffit de sélectionner le symbole correspondant dans la zone de sélection d'outils d'édition.
<img title="" src="./files/img/new_project.png" alt="" data-align="center">
En sélectionnant le bloc de la **Fonction** il est possible de modifier ses propriétés graphiques par l'intermédiaire de la zone d'édition. Le choix est laissé à l'utilisateur d'afficher ou de masquer le nom ou la description de la **Fonction**.
<img title="" src="./files/img/modify_function.png" alt="" data-align="center">
Des images peuvent aussi être importées (.jpg, .gif, .png) dans les propriétés graphiques. Pour se faire, cliquer sur afficher une image dans les propriétés graphiques.
### Saisie des liens
Les liens permettent de relier deux éléments (**Fonction**). La création des **liens** est réalisée à l'aide de l'outil de liaison  dans le zone de sélection d'outils d'éditions. Pour créer un **Lien**, sélectionner un élément (**Fonction** ou **Connecteur**) en cliquant sur l'entrée (**Connecteur**) ou la sortie (**Fonction**), le **Lien** apparaît alors en pointillé. Glisser la souris jusqu'à l'élément d'arrivée et cliquer sur la sortie (**Connecteur**) ou l'entrée (**Fonction**). Le **Lien** apparaît alors en trait plein.
<img title="" src="./files/img/link_elements.png" alt="" data-align="center">
Note : il est également possible de créer les liens à l'aide de l'outil dédié en cliquant sur **Données** puis **Traitements automatisés** et sélectionner **Créateur de lien**.
Une fenêtre apparaît alors, au travers de laquelle il est possible de générer un lien. Pour ce faire, sélectionner dans le menu déroulant (présentant l'arborescence des **Sorties**) le point de départ du lien puis, de la même manière, la destination du lien. Cliquer sur Appliquer pour créer le lien.
<img title="" src=".\files\img\Outils%20créateur%20de%20lien%20fenêtre.PNG" alt="Outils créateur de lien fenêtre.PNG" data-align="center">
### Ajout de connecteurs Entrée et Sortie
Pour les besoins de la modélisation, il peut être nécessaire de créer plusieurs **Entrées** ou **Sorties**.
La création d'une **Entrée** est réalisée par l'outils  dans la zone de sélection d'outils d'édition. On notera qu'il est impossible de créer des liens vers un **Entrée**.
De la même manière, la création d'une **Sortie** est réalisée par l'outil  dans la zone de sélection d'outils d'édition. Il est impossible de créer des liens depuis une **Sortie**.
Si des liens bilatéraux existent entre deux éléments, plutôt que de multiplier les **Entrées** et **Sorties**, il est possible d'utiliser l'outil multiplexage .
### Créer des évènements
A ce stade de la modélisation, les **Fonctions** du système à modéliser et les **Liens** existants entre elles sont définis. Pour caractériser le comportement dysfonctionnel et plus précisément les modes de défaillance de chacune des fonctions, il est nécessaire de créer des **Evènements**.
Pour ce faire, double cliquer sur la **Fonction** et ajouter un évènement en cliquant sur ce symbole .
Cet évènement, situé entre l'entrée et la sortie de la Fonction 1, agira comme un perturbateur du flux. Il doit, de la même manière que les **Fonctions**, être rattaché à l'**Entrée** et la **Sortie** de la fonction à l'aide de **Liens**.
#### Propriétés graphiques de l'évènement
En sélectionnant l'**évènement**, il est possible de modifier ses propriétés graphiques par l'intermédiaire de la zone d'édition. Le choix est laissé à l'utilisateur d'afficher ou de masquer le nom du mode de défaillance et son effet local. Ce dernier est utile pour la construction des analyses AMDEC.
#### Modifier le type d'évènement
Il est possible de lui changer son **Type** en faisant un clic droit puis **Changer le type**. Cette information permettra, lors de la réalisation des calculs, de discrétiser les modes de défaillances analysés en fonction de leur incidence (**Type**) sur le système.
##### Paramétrer l'évènement
Pour remplir les paramètres quantitatifs nécessaires à toute loi de fiabilité, vous devez d'abord entrer les *paramètres nommés* en allant dans **Données** :
Dans cette fenêtre, il est possible de créer autant de paramètres que nécessaire, de les modifier ou de les supprimer.
En double-cliquant sur l'évènement vous accéderez aux données quantitatives de celui-ci et vous pourrez choisir la *Loi*, le *Alpha* et la *Cause*, puis nommer les paramètres.
Le paramètre **Alpha** est à 1 par défaut. il représente la répartition du mode de défaillance considéré, au regard du taux de défaillance ou lambda renseigné, pour cet **Evènement**.
Le champ **Cause** représente les cause(s) possible(s) du mode de défaillance, qu’elle(s) soi(en)t d’origine interne ou externe. Ce champ est utile pour la construction des analyses AMDEC.
### Saisir des fonctions dynamiques
#### Généralités
System-Analyst utilise le moteur de simulations **AGATE** (**A**nother **G**u**A**rded **T**ransition **E**ngine) qui permet de réaliser les évaluations suivantes:
- Simulation pas-à-pas avec prise en compte du temps abstrait;
- Génération des coupes minimales les plus probables
- Génération des séquences critiques;
- Gérération des séquences critiques minimales;
- Simulation stochastique;
- Génération stochastique des séquences critiques.
La génération des arbres de défaillances vers l'application Arbre-Analyst n'est pour le moment possible que pour les modèles purement statiques c-à-d qui ne comprennent pas de "fonction dynamique".
Le moteur de simulations AGATE est un nouveau moteur qui vise l'évaluation et la simulation de modèles GTS (Guarded Transition Systems) tels que les modèles AltaRica V3 avec comme principal objectif de permettre l'évaluation de modèles de grandes tailles en réduisant fortement la durée et l'empreinte mémoire des simulations.
Il y a deux méthodes pour saisir des fonctions dynamiques dans System-Analyst:
- au travers d'une fenêtre d'édition qui permet de saisir les modèles dans le language AltaRica V3 (https://www.altarica-association.org/) puis de les *compiler* de façon transparente dans le *bytecode* à destination du simulateur AGATE 
- au travers de la saisie manuelle du *bytecode* des modèles dynamiques. Cette méthode de saisie est réservée à des utilisateurs avancés dans le but notamment d'optimiser les performances de la simulation (c-à-d de réduire la durée des simulations).
#### Saisir un modèle dynamique directement en *bytecode*
**Généralités**
En informatique, le bytecode est un code intermédiaire entre les instructions machines et le code source du modèle, qui n'est pas directement exécutable.
Il s'agit des instructions "optimisées" qui seront "interprétées" par le moteur de simulation AGATE et traduits en instructions machines. Passer par cette étape de "bytecode" permet d'obtimiser drastiquement les simulations soit en amont par l'ingénieur en charge du modèle soit en aval par le moteur de simulations.
**Description des "instructions" du bytecode**
Par la suite, les éléments encadrés par des crochets sont optionnels et "→" représente le caractère tabulation.
* Constante
* 'ID'→**set**→'VALUE'
* Variable d'état
* 'ID'→**state** 'INIT VALUE'→'PREDECESSEUR ID'[ 'PREDECESSEUR ID' 'PREDECESSEUR ID']
Nota: une variable d'état peut prendre toutes les valeurs excepté la valeur **"0"**
* If-then-else
* 'ID'→**=**→'PREDECESSEUR ID' 'PREDECESSEUR ID' 'PREDECESSEUR ID' 'PREDECESSEUR ID'
* 'ID'→**>**→'PREDECESSEUR ID' 'PREDECESSEUR ID' 'PREDECESSEUR ID' 'PREDECESSEUR ID'
* 'ID'→**>=**→'PREDECESSEUR ID' 'PREDECESSEUR ID' 'PREDECESSE^^UR ID' 'PREDECESSEUR ID'
* 'ID'→**<**→'PREDECESSEUR ID' 'PREDECESSEUR ID' 'PREDECESSEUR ID' 'PREDECESSEUR ID'
* 'ID'→**<=**→'PREDECESSEUR ID' 'PREDECESSEUR ID' 'PREDECESSEUR ID' 'PREDECESSEUR ID'
* 'ID'→**!=**→'PREDECESSEUR ID' 'PREDECESSEUR ID' 'PREDECESSEUR ID' 'PREDECESSEUR ID'
Nota:
* pour modéliser une logique ET chaîner deux IF-THEN-ELSE au niveau du troisième paramètre "THEN"
* pour modéliser une logique OU chaîner deux IF-THEN-ELSE au niveau du quatrième paramètre "ELSE"
* Math
* 'ID'→**add**→'PREDECESSEUR ID'[ 'PREDECESSEUR ID' 'PREDECESSEUR ID']
* 'ID'→**sub**→'PREDECESSEUR ID'[ 'PREDECESSEUR ID' 'PREDECESSEUR ID']
* 'ID'→**mul**→'PREDECESSEUR ID'[ 'PREDECESSEUR ID' 'PREDECESSEUR ID']
* 'ID'→**div**→'PREDECESSEUR ID'[ 'PREDECESSEUR ID' 'PREDECESSEUR ID']
* 'ID'→**min**→'PREDECESSEUR ID'[ 'PREDECESSEUR ID' 'PREDECESSEUR ID']
* 'ID'→**max**→'PREDECESSEUR ID'[ 'PREDECESSEUR ID' 'PREDECESSEUR ID']
* 'ID'→**#**→'PREDECESSEUR ID'[ 'PREDECESSEUR ID' 'PREDECESSEUR ID']
* 'ID'→**inc**→'PREDECESSEUR ID'[ 'PREDECESSEUR ID' 'PREDECESSEUR ID']
* Evènement
* 'ID'→**event** 'VALUE'→'PREDECESSEUR ID'
* 'PREDECESSEUR ID' correspond à la garde de l'évènement. La garde est considérée comme levée lorsque sa valeur est différente de 0. Autrement dit, l'évènement ne peut pas être tiré lorsque la valeur de son prédécesseur est égale à 0.
* Dans le cadre de simulations stochastiques, la date est tirée lorsque la garde est levée et reste tirable tant que la garde ne redescend pas.
**Organisation de la fenêtre d'édition**
La fenêtre d'édition de modèles dynamiques est construite de la façon suivante:
1. _Edition des entrées/sorties_: ce champ permet de saisir les entrées et les sorties du bloc/fonction en cours d'édition. Il est très important pour la suite de noter les "id" proposés pour chacune des entrées/sorties.
2. _Edition du bytecode du modèle_ : ce champ permet à l'utilisateur de saisir manuellement le bytecode. Les évènements qui auront été saisis seront automatiquement ajoutés à la liste paramétrable des évènements.
3. _Edition des évènements_: ce dernier champ permet de paramétrer les évènements qui auront été saisis précédement dans le bytecode du modèle.
**Exemple de bytecodes**
Prenons le cas d'un composant simplement non-réparable. Ce composant peut prendre deux états:
- "panne"
- "en fonctionnement".
Ce composant comprend un évènement
- "failure" qui entraine la panne;
Lorsque le composant est en fonctionnement, sa sortie prend la valeur de son entrée. En revanche, si le composant est en panne, sa sortie prend la valeur "faux".
ATTENTION: pour une question de lisibilité dans l'exemple ci-après, le caractère "→" représente le caractère "tabulation".
// ============================================================
// Déclarer des constantes
// ID→set→valeur
10→set→0
11→set→1
12→set→2
// ============================================================
// Déclarer une variable d'état
// La variable d'état prendra deux valeurs:
// - 1 : représentant l'état "en fonctionnement" (la variable d'état sera initialisée à la valeur 1)
// - 2 : représentant l'état "panne"
// ATTENTION: une variable d'état peut prendre toutes les valeurs sauf la valeur "0"
// ID→state INIT→prédécesseurs séparés par un espace
15→state 1→21
// ============================================================
// Déclarer une transition. Une transition est constituée:
// d'une garde
20→=→15 11 11 10
// d'un évènement
21→event 2→20
// d'une action (dans notre cas ici, l'action consiste à passer la valeur "2" à la variable d'état dont l'id est "15". Cette variable d'état a donc l'évènement "21" comme prédécesseur)
// ============================================================
// Déclarer les assertions avec
// l'entrée de notre fonction qui prend l'id 31
// la sortie de notre fonction qui prend l'id 32
32→=→15 11 31 10
// Notre sortie "32" prend la valeur de notre entrée "31" si notre variable d'état "15" est égale à la valeur de notre constante "11" sinon notre sortie "32" prend la valeur de la constante "10".
// ============================================================
### Modélisation des redondances
Lorsque deux fonctions ou évènements sont reliés à une même sortie, la logique de la modélisation fonctionnelle considère ces deux éléments comme assurant une redondance. Sur la modélisation ci-après, la fonction 1 ET la fonction 2 doivent être défaillantes pour que la sortie soit défaillante.
<img title="" src="./files/img/Modélisation_redondance.png" alt="Modélisation_redondance.png" data-align="center">
Pour modéliser le fait que les deux fonctions sont nécessaires et que la défaillance de l'une ou de l'autre mène à la défaillance de la sortie, on utilise l'outils créer un porte logique .
Par défaut une porte ET apparaît sur la fenêtre de dessin qu'il convient de relier aux sorties des deux fonctions.
<img title="" src="./files/img/Modélisation_redondance_ET.png" alt="Modélisation_redondance_ET.png" data-align="center">
Il est possible de lui changer son **Type** en faisant un clic droit puis **Changer le type**. On peut ainsi modéliser une porte ET, une porte OU ou une porte K/N.
****N**** correspond au nombre de connections en entrée de la porte.
Si au moins **K** d'entre elles sont à VRAI, alors la valeur booléenne transmise par la sortie du connecteur est VRAI sinon c'est FAUX. La valeur de **k** peut être modifiée en faisant un clic droit puis **Changer la valeur de K**.
### Aide à la saisie
#### Dupliquer des éléments
Les actions basiques comme **Copier** / **Coller** / **Couper** / **Supprimer** sont accessibles grâce au clic droit ou en utilisant les boutons de raccourcis
<img title="" src="./files/img/copy_paste.png" alt="" data-align="center">
Les éléments "copié-collé" présentent les mêmes caractéristiques que l'élément initial. En revanche, ils sont considérés comme deux fonctions ou évènements indépendants.
Il est possible de sélectionner des éléments et de les aligner **verticalement**:
<img title="" src="./files/img/vertical_position.png" alt="" data-align="center">
ou **horizontalement**:
<img title="" src="./files/img/horizontal_position.png" alt="" data-align="center">
Afin de ne pas surcharger le modèle avec des liens, il est possible de les réduire en faisant un clic droit puis modifier le format du lien.
<img title="" src=".\files\img\Lien%20Long.png" alt="Lien Long.png" width="650">
#### Gestion des entrées/sorties (I/O)
Lorsque l'on réalise un modèle, le déplacement des I/O d'un côté ou de l'autre de la fonction ou dans un ordre particulier peut être utile pour faciliter la lisibilité de la modélisation. Le déplacement des I/O sur une fonction est réalisé par un clic droit sur la fonction puis en sélectionnant **Action**, **I/O**.
Plusieurs possibilités sont alors proposées :
- Pivoter les I/O vers la droite : l'ensemble des I/O de la fonction seront pivotées sur la coté adjacent dans le sens horaire ;
- Pivoter les I/O vers la gauche :l'ensemble des I/O de la fonction seront pivotées sur la coté adjacent dans le sens antihoraire ;
- Gauche : Sur les I/O de gauche de la fonction, le menu permet :
- Afficher/ Masquer le nom ou la description. Le nom et la description sont modifiables dans les propriétés graphiques de l'I/O, accessibles en cliquant sur l'élément (nécessite de rentrer dans la fonction pour sélectionner l'I/O) ;
- Ordre Croissant / Décroissant : Permet de trier les I/O selon leur nom.
- Créer les I/O complémentaires : cette fonctionnalité permet de créer les entrées ou sorties associées à celle(s) existante(s), sur le côté opposé de la fonction.
- Créer les I/O externes : cette fonctionnalité permet de créer les entrées ou sorties externes à la fonction associée.
- Déplacer dans une direction : l'ensemble des I/O gauches sont déplacées dans la direction souhaitée.
- Droite : Mêmes fonctionnalités pour les I/O de Droite
- Bas : Mêmes fonctionnalités pour les I/O du Bas
- Haut : Mêmes fonctionnalités pour les I/O du Haut
Note : pour modifier de manière individuelle une I/O (changer l'ordre ou le côté), cliquer droit sur celle-ci et sélectionner **Changer de côté** ou **Changer d'ordre**.
#### Ajout d'éléments graphiques
Il est possible d'ajouter des éléments graphiques de type rectangle ou texte afin d'apporter des informations complémentaires sur le modèle. L'ajout d'un rectangle est réalisé à partir de l'outils  et la zone de texte à partir de l'outils .
En sélectionnant l'objet inséré, il est possible de modifier ses propriétés graphiques par l'intermédiaire de la zone d'édition.
Par défaut, les éléments ajoutés sont placés au premier plan de la fenêtre. Les éléments de la fenêtre de dessin peuvent être positionnés au *premier-plan* ou *l'arrière-plan* par un clic droit.
#### Gestion des sous-ensembles
Lorsque le modèle se complexifie, il peut être utile de grouper une partie des **Fonctions** pour simplifier la lecture et la compréhension du modèle.
Pour ce faire il suffit de créer une **Fonction** qui s'apparentera à un **Sous-ensemble**.
<img src=".\files\img\Sous-ensemble.png" title="" alt="Sous-ensemble.png" data-align="center">
Pour déplacer les fonctions à l'intérieur d'un sous-ensemble, il suffit de :
- les sélectionner en cliquant sur chacun d'eux et en maintenant la touche CTRL du clavier appuyée
- les couper en faisant un clic droit couper
- double cliquer sur le sous-ensemble et coller.
On notera que les liens avec les entrées et sorties du sous-système seront à créer.
Pour remonter au niveau supérieur, naviguer dans l'arborescence sur la droite de l'écran ou clic droit et remonter au niveau supérieur.
<img title="" src="./files/img/Niveau%20sup.png" alt="Niveau sup.png" data-align="center">
## Réalisation des calculs de probabilité <a name="calculs"></a>
Une fois que le modèle est réalisé, SYSTEM ANALYST permet de réaliser un certain nombre d'analyses :
- la génération des coupes minimales ;
- la génération d'un arbre de défaillance.
Ces éléments peuvent être générés grâce à un clic droit sur la sortie à étudier, en sélectionnant l'analyse à réaliser. Le choix est alors donné de sélectionner le type de défaillance du modèle à traiter (en lien avec le **Type** choisi précédemment pour chacun des événement modélisé).
Les analyses peuvent également être créées à partir d'un **Observeur**.
La création d'un ***Observeur*** est réalisée via le symbole .
L'**Observeur** a la particularité de pouvoir synthétiser les effets des défaillances observées. Ainsi, en double cliquant dessus, il permet à l'utilisateur de sélectionner, pour chaque **Type** de défaillance, l'effet au niveau du système.
Les effets systèmes génériques peuvent être modifiés en cliquant sur Données puis Effets finaux.
Nota : l'indication de gravité de chaque effet est utile pour la génération des analyses AMDEC.
Comme cela se fait à partir d'une sortie, générer les *coupes minimales* ou les *arbres de défaillances*, peut se faire par un clic droit sur l'***Observeur***.
<img src="./files/img/compute_observer.png" title="" alt="" data-align="center">
La génération des arbres de défaillance produit un fichier au format .OPSA (Open-PSA) lisible notamment avec le logiciel [ARBRE ANALYSTE](https://www.arbre-analyste.fr).
La génération des coupes minimales ouvre une fenêtre permettant de lancer les calculs sur un temps de mission donné.
Nota : En cas de calculs importants, il est possible de borner le calcul à un certain nombre de coupes. Ceci permettra de gagner en temps de calcul.
<img src=".\files\img\Zone%20calcul.png" title="" alt="Zone calcul.png" data-align="center">
En cliquant sur le bouton **Exporter**, un fichier **Excel** présentant les résultats est créé.
## Réalisation d'une analyse de testabilité <a name="testabilite"></a>
A partir de la modélisation d'un système, il est possible de réaliser une analyse de testabilité, dont l'objectif est de déterminer le taux de couverture et le taux de localisation du système analysé. L'analyse de testabilité nécessite la réalisation des actions suivantes :
- définition des paramètres logistiques du système
- mise en place des moyens de test
Nota : les effets finaux du modèle doivent être définis à l'aide des **Observeurs**.
### Définition des paramètres logistiques
Les paramètres logistiques permettent de définir les éléments dits remplaçables en ligne et remplaçables en atelier. La désignation de ce niveau logistique diffère selon les applications. On retrouve souvent les notions de LRU/LRA ou URL/URA.
La définition des paramètres logistiques est réalisée en cliquant sur **Données** puis sur **Paramètres logistiques**.
<img src=".\files\img\Menu%20paramètre%20logistique.png" title="" alt="Menu paramètre logistique.png" data-align="center">
Une fenêtre présentant l'arborescence du système s'ouvre. En double cliquant sur chacun des éléments, il est possible de lui définir son niveau de remplacement.
Dans l'exemple présenté, le **Sous ensemble 1** est défini comme une URL et les **Fonctions** comme des URA. On notera que la dénomination des niveaux de remplacement est laissée à l'appréciation de l'utilisateur.
### Mise en place des moyens de tests
#### Création des tests
Pour évaluer les performances en termes de testabilité d'un système, il est nécessaire de connaître les tests existants et les défaillances qu'ils permettent d'identifier.
La définition des tests est réalisée à partir de l'outils **Créer un test**  dans la zone de sélection d'outils d'édition. Une fois créé, le test est à relier à la sortie d'un élément (fonction, sous-ensemble ou mode de défaillance). Il est possible de modifier ses propriétés graphiques par l'intermédiaire de la zone d'édition. Dans l'exemple ci-dessous, seule la fonction numéro 2 dispose d'un test permettant de détecter ses défaillances.
Note : Il est possible de relier plusieurs sorties à un même test. Dans ce cas, il faut valider les conditions de détection de ce dernier. En effet, si le test est capable de déceler les défaillances des deux sous-ensembles indépendamment, l'utilisation d'une porte logique est nécessaire.
#### Configuration des tests
La configuration des tests est réalisée en double cliquant sur l'élément. La fenêtre de configuration s'ouvre.
Les fonctionnalités sont les suivantes :
- Choix entre test simple et test de chaîne:
Le test simple permet de détecter toutes pannes en amont de l'élément auquel il est rattaché.
Concernant le test de chaîne, il est possible de paramétrer la chaîne d'éléments dont les défaillances sont détectables par le test. Cette fonctionnalité est utile notamment quand la fonction de test concerne l'injection d'un signal (OL de test) à un point donné d'une chaîne de traitement du signal.
Pour définir le point d'entrée d'un test de chaine, cliquer sur test de chaîne, puis sur Ajouter.
<img src=".\files\img\Test%20Chaine.png" title="" alt="Test Chaine.png" data-align="center">
Une fenêtre permet de sélectionner, à l'aide l'entrée du test de chaîne.
- La détermination du taux de couverture du test.
- La sélection des effets de défaillances couverts par le test.
La sélection peut être automatique via la sélection ou manuelle en cliquant sur **Ajouter**.
### Lancer une analyse de testabilité
Pour lancer l'analyse de testabilité, cliquer dans le menu sur **Calculer** puis **Analyse de testabilité**.
<img title="" src="./files/img/Lancer%20testa.png" alt="Lancer testa.png" data-align="center">
Dans la fenêtre de calcul, sélectionner le niveau logistique sur lequel l'analyse de testabilité est à réaliser, les tests à prendre en compte et les effets considérés. Cliquer ensuite sur démarrer pour obtenir les résultats.
En cliquant sur **Obtenir les résultats détaillés**, un fichier Excel présentant les résultats est généré.
Les résultats présentent :
- Le taux de défaillance des éléments ;
- Le taux de défaillance critique des éléments (directement issu de la sélection des effets finaux considérés) ;
- Le taux de défaillance couvert par les tests sélectionnés ;
- les taux de localisation des pannes à 1,2 ou 3 éléments près.
Deux types de quantification de la localisation des défaillances sont supportés par l'outil:
1. **Taux de localisation de défaillance (FIP : Failure Isolation Probability)**: le FIPn correspond à la probabilité pour une séquence de test d’isoler la défaillance dans un groupe
d’ambiguïté composé de n URL.
2. **Taux de Résolution de Panne à l’URL majoritaire (FRP : Failure Resolution Probability)**: le FRPn correspond à la probabilité de réparer la défaillance par remplacements successifs de n URL.
L’idée étant de remplacer en premier, parmi les URL incriminés, l’URL dont les défaillances détectées ont le
taux de défaillance cumulé le plus grand du groupe d’ambiguïté.
## Fonctionnalités avancées <a name="avance"></a>
### Auto-Répartition des taux de défaillance
Cette fonctionnalité peut être utilisée lorsque l'on souhaite équi-répartir le taux de défaillance d'une **Fontion** entre les différents **Evenements** la constituant.
Dans l'exemple suivant, une fonction est constituée de quatre événements.
En cliquant sur **Données** puis **traitements automatisés**, et **Auto-répartition des taux de défaillance**, il est possible de créer un paramètre nommé et de l'allouer à chacun des évènements de la fonction de manière automatique.
Dans la fenêtre, double cliquer sur la **Fonction** à traiter puis indiquer le taux de défaillance total de la fonction et cliquer sur Appliquer.
L'outil a alors créé un paramètre nommé, dédié à la fonction traitée et à réparti, à l'aide du **Alpha** le taux de défaillance de la fonction sur les évènements la composant.
Note : l'intitulé du paramètre nommé peut être modifié selon les besoins de l'utilisateur dans le menu dédié à cet effet.
### Création de modes de défaillance
La création des modes de défaillance d'une fonction peut être réalisée en automatique. Cette fonctionnalité est utile aussi bien pour des fonctions simples disposant d'une entrée et d'une sortie que des fonctions plus complexes. Pour créer les modes de défaillance de manière automatique, cliquer sur **Données** puis **traitements automatisés**, et **Création de modes de défaillance**,
Dans la fenêtre, double cliquer sur la **Fonction** à traiter puis indiquer le taux de défaillance total de la fonction. Dans le menu déroulant, deux options sont possibles :
- All inputs : Création d'un mode de défaillance associé à chaque sortie avec une dépendance sur l'ensemble des entrées.
- Same name : Création d'un mode de défaillance associé à chaque sortie et dépendant uniquement de l'entrée du même nom.
Dans l'exemple ci-après, la fonction 3 dispose de 2 entrées et de 2 sorties ayant des noms identiques. Selon le mode de création des modes de défaillance, les évènements associés à la fonction sont créés en dépendant soit des entrées ou soit uniquement de l'entrée portant le même nom.
]]>