# Jeux d'alias

> Des jeux nommés de noms de voies, un par produit par exemple, appliqués à une unité à côté de ses liaisons ou épinglés à une procédure pour que la préparer les applique.

Un **jeu d'alias** est une colonne nommée de noms de voies : pour chaque voie du modèle qu'une unité
peut renommer, le nom sous lequel cette unité lit la voie une fois le jeu appliqué. C'est la façon de
renommer toute une unité en un seul geste, pour un produit ou un client, au lieu de resaisir chaque
alias. Il vit sous Process > Modèles > modèle > Réglage > **Alias**, et il exige la permission
**Modifier recettes et évaluations**. Un jeu d'alias est de la présentation seulement : le nom propre
de la voie reste la clé que référence chaque objet du modèle.

## Le dossier Alias {#the-aliases-folder}

Sélectionner la ligne **Alias** ouvre la page du dossier (« Des jeux nommés de noms de voies, un par
produit par exemple. Appliquer un jeu à une unité renomme ses voies en un seul geste, et une
procédure peut en épingler un pour que sa préparation applique le jeu. ») avec une carte par jeu ;
cliquer sur une carte l'ouvre et le X le retire. Sans aucun, la page indique « Aucun jeu d'alias pour
l'instant. Ajoutez-en un pour nommer les voies de ce modèle pour un produit ou un client, puis
appliquez-le à une unité à côté de ses liaisons. »

| Commande | Ce qu'elle fait | Grisée quand (situation) | Non dessinée quand (rôle) |
| --- | --- | --- | --- |
| **Jeu d'alias** (barre de détail, dossier sélectionné ; clic droit **Ajouter un jeu d'alias**) | Ajoute `Jeu d'alias <n>`, qui ne nomme encore rien. La ligne rejoint son groupe, mise en évidence et amenée dans la zone visible ; sa carte l'ouvre. | Une unité quelconque tient un essai, ou le runtime est arrêté. | Sans Modifier recettes et évaluations. |

## La page du jeu {#the-sets-page}

L'en-tête porte le nom du jeu et un badge qui compte ce qu'il renomme : « 1 voie nommée » ou
« `<n>` voies nommées ». Un jeu qui ne nomme rien ne change rien quand il est appliqué.

### Définition {#definition}

| Champ | Ce que c'est | Valeurs / défaut | Effet |
| --- | --- | --- | --- |
| **Nom** | Le nom du jeu dans l'arborescence, dans le sélecteur Appliquer de l'écran Voies et dans le sélecteur Jeu d'alias d'une procédure. | Texte libre, validé quand vous quittez le champ ; `Jeu d'alias <n>` à la création. | Renomme la ligne d'arborescence. |

### Noms des voies {#channel-names}

La carte explique sa propre règle : « Un alias vide laisse cette voie sous le nom qu'elle porte déjà.
Appliquer ce jeu à une unité écrase tous les alias de cette unité, donc ce qu'il ne nomme pas revient
au nom propre de la voie. » En dessous se tient une grille avec une ligne par voie du modèle, dans
l'ordre des voies du modèle, donc une voie est nommée au plus une fois par construction.

| Colonne | Ce que c'est | Valeurs / défaut |
| --- | --- | --- |
| **Voie** | La voie, sous la forme `Ch<number> · <name>`. | En lecture seule. |
| **Nom d'alias** | Le nom que ce jeu donne à la voie. Le texte d'exemple montre le nom sous lequel la voie se lit sur le modèle (son alias propre, ou son nom). | Texte libre, validé quand vous quittez le champ ; vide par défaut. Saisir un nom crée l'entrée ; le vider retire l'entrée, donc le jeu n'enregistre que les voies que vous avez réellement nommées. |

Une voie que le modèle garde sous un seul nom (sa **Portée de l'alias** sur **Tout le modèle** dans
le tableau Voies) refuse l'entrée : la cellule est désactivée avec l'infobulle « Cette voie garde un
seul nom pour toutes les unités. Pour la nommer dans un jeu, réglez d'abord sa Portée de l'alias sur
Chaque unité dans le tableau Voies. » Un jeu est la façon de renommer une unité, donc il ne peut pas être le moyen de
contourner cette déclaration.

## Qui applique un jeu {#who-applies-a-set}

Un jeu ne fait rien par lui-même. Deux gestes l'appliquent à une unité, et tous deux sont un écrasement
complet et visible des alias par unité de cette unité : chaque voie que le jeu nomme prend le nom du
jeu (la liaison est créée si la voie n'était pas encore liée), chaque voie renommable que le jeu ne
nomme pas voit son alias effacé et revient au nom propre de la voie, et une voie que le modèle garde
sous un seul nom est laissée intacte dans les deux cas.

| Geste | Où | Ce qui se passe |
| --- | --- | --- |
| **Appliquer** à côté des liaisons d'une unité | Définition > Voies : choisissez une unité dans la liste des unités ; le sélecteur de jeu et **Appliquer** se tiennent avec le tableau de liaisons de cette unité (« Appliquer aux alias ci-dessus un jeu nommé de noms de voies. Appliquer ce jeu à une unité écrase tous les alias de cette unité, donc ce qu'il ne nomme pas revient au nom propre de la voie. Les modifications manuelles l'emportent jusqu'à une nouvelle application. »). Voir [Voies et liaisons](process-channels#the-binding-table-of-the-picked-unit). | Le jeu est écrit aussitôt sur les alias de cette unité et enregistré. Les alias que vous modifiez à la main ensuite restent jusqu'à ce que vous appliquiez un jeu de nouveau. |
| Une procédure **épingle** un jeu | Réglage > Procédures : l'étape **Nom** de la procédure a un sélecteur **Jeu d'alias**. | L'épinglage est vérifié quand la procédure est préparée sur une unité : si les alias de cette unité correspondent déjà au jeu, rien n'est écrit ; s'ils diffèrent, le jeu est appliqué à l'unité et enregistré au moment où la procédure est préparée, et le journal enregistre « Alias set pinned: '`<set>`' applied to '`<model>` · `<unit>`' by staging '`<procedure>`' ». Écrire le jeu est un changement de configuration, donc la préparation est refusée tant qu'une unité exécute un essai, avec « Cette procédure épingle un jeu d'alias de voies. L'appliquer modifie la configuration, verrouillée pendant qu'une unité tourne. », et l'unité garde la procédure qu'elle avait préparée. Si le jeu ou les alias de l'unité bougent ensuite, le démarrage est refusé avec « Le jeu d'alias épinglé de la procédure n'est pas appliqué sur cette unité. Préparez de nouveau la procédure. » |

La ligne d'étape de la page de la procédure indique « Renomme `<n>` voies sur l'unité quand cette
procédure y est préparée », ce qui nomme le moment où l'écriture a lieu, comme ci-dessus.

Les deux gestes sont des écritures de configuration : ils refusent tant qu'une unité quelconque tient
un essai et tant que le runtime est arrêté, et le bouton Appliquer de l'écran Voies exige la
permission Gérer Process qu'exige cet écran.

## Où l'alias se montre {#where-the-alias-shows}

Le nom en vigueur pour une voie sur une unité est une seule règle : l'alias propre de l'unité quand
la voie en permet un et que l'unité en tient un, sinon l'alias propre de la voie, sinon le nom de la
voie. Un jeu d'alias n'écrit que le premier des trois.

| Surface | Ce qu'elle lit |
| --- | --- |
| La carte **Voies** d'un volet sous Conduite et sur la page View | Chaque série est nommée par le nom en vigueur sur cette unité. |
| Un tableau de bord résolu du modèle | Le jeton `{channel.name:...}` devient le nom en vigueur (voir [Tableaux de bord d'un modèle](process-dashboards)). |
| Le fichier d'essai | Le démarrage fige l'alias en vigueur pour chaque colonne enregistrée, à côté du nom et du numéro de la voie. |
| Le graphique de l'essai dans les Historiques | Chaque colonne se lit `Ch<number> · <alias>`, ou le nom de la voie quand aucun alias n'était en vigueur. |
| Le rapport PDF | L'alias figé dans l'essai, ou le nom de la voie quand il n'y en avait pas. |
| Les exports CSV et XLSX | Chaque colonne a pour en-tête l'alias figé dans l'essai, ou le nom de la voie quand il n'y en avait pas, avec son unité physique. |
| Les adresses Logic, les conditions d'occurrence | Le nom de la voie. Un alias ne change jamais `Process.<Model>.<Unit>.Channels.<Channel>` ni `Channels.<Channel>` dans une condition. |

## Retirer le jeu d'alias {#remove-alias-set}

**Retirer le jeu d'alias** se tient dans le groupe de danger de la barre de détail avec le jeu
sélectionné, sur son menu contextuel, et comme le X sur la carte de la page du dossier. Il demande
d'abord (« Supprimer le jeu d'alias », « Ceci retire le jeu d'alias et ses entrées. »).
Une procédure qui avait épinglé le jeu vide sa référence Jeu d'alias ; une unité à laquelle le jeu
avait été appliqué garde les alias déjà écrits, parce que ce sont ceux de l'unité. Il exige Modifier
recettes et évaluations et est grisé sous le verrou d'ingénierie et le runtime arrêté.

## Ce qu'un jeu d'alias ne fait pas {#what-an-alias-set-does-not-do}

- Il ne renomme aucune voie et aucune adresse. Les noms de voie du modèle, l'espace d'adressage
  Logic et les conditions d'occurrence gardent le nom propre de la voie.
- Il ne s'applique pas tout seul. Modifier un jeu après qu'il a été appliqué ne change rien sur
  aucune unité jusqu'à ce que le jeu soit appliqué de nouveau, à la main ou en préparant une
  procédure qui l'épingle.
- Il ne peut pas nommer une voie que le modèle garde sous un seul nom, et il ne peut pas activer cet
  interrupteur : cette décision appartient à la voie, dans le tableau Voies.
- Il n'écrit rien dans une unité en marche : appliquer est une écriture de configuration et attend le
  verrou d'ingénierie comme toutes les autres.
