Le langage de commande ====================== Python et le langage de commande -------------------------------- Un fichier de commandes pour le *Code_Aster* est exclusivement composé d’instructions Python. La première des contraintes est donc de se conformer aux règles de ce langage. On pourra lire le tutoriel Python ( `www.python.org `_) ou les nombreux livres d’introduction à Python pour plus de détail, mais ce n’est pas nécessaire pour l’usage d’Aster. Un fichier de commandes peut contenir des instructions python de deux natures: des commandes *Aster* et … n’importe quelle autre instruction python. En effet, un fichier de commandes est un programme python à part entière et on peut en particulier y placer des structures de contrôle (boucles), des tests (if), des calculs numériques, des appels à des fonctions de pré et post-traitement. Dans le cadre d’une utilisation «classique» du code où le fichier de commande contient exclusivement des commandes Aster, les deux règles spécifiques à Python à retenir sont: * Pas d’indentation sur la première ligne de déclaration d’une instruction. mail = LIRE_MAILLAGE ( ) Il ne faut placer ni blanc, ni tabulation avant la chaîne de caractères mail. * Les arguments des fonctions, autrement dit les mots clés des commandes, sont séparés par des virgules; ils se composent d’un mot clé, du signe «=», du contenu du mot clé. **Important:** L’éditeur EFICAS ne permet de produire que des fichiers de commandes de ce type: contenant exclusivement des commandes ASTER, sans autre instruction Python. Utiliser EFICAS garantit essentiellement trois choses: * le fichier produit aura une syntaxe python correcte, * les commandes produites seront cohérentes avec le catalogue de commandes, * les concepts produits seront correctement enchaînés (pas d’utilisation d’un concept sans qu’il ait été créé par une commande précédente). L’utilisateur ayant composé ainsi son fichier de commande sera à l’abri d’un arrêt à l’exécution au motif d’un problème de syntaxe. Notion de concept ----------------- Définition : on appelle *concept* les structures de données Aster, que l'utilisateur peut manipuler et nommer. Ces concepts sont typés au moment de leur création et ne pourront être utilisés que comme argument d'entrée du type correspondant dans une commande ultérieure. La notion de concept permet donc à l'utilisateur de manipuler des objets symboliquement et indépendamment de leur représentation interne (qu'il peut ne pas connaître). D’ailleurs, l’objet python désigné par le nom du concept ne contient aucune autre information que son type, sa classe au sens python (cf. doc D). Son nom, transmis par le superviseur au FORTRAN, permet à Aster de retrouver la structure de données correspondante dans la base globale. Mais il n’est pas possible d’avoir visibilité de la structure de données depuis le fichier de commande. Par exemple, les instructions suivantes ne permettent pas d’imprimer la structure de données de type maillage et de nom mail: mail=LIRE_MAILLAGE ( ) print mail mais génèrent le message suivant: Il y a une exception à cette règle: les tables. En effet, un artifice de programmation permet de récupérer simplement de l’information contenue dans une structure de donnée TABLE en manipulant celle-ci comme un tableau à deux entrées: .. code-block:: text pour imprimer une valeur: print resu[ ‘DX’ , 1] pour l’affecter à une variable: valeur = resu[ ‘DX’ , 1] Cela suppose bien sûr que la structure de données resu, de type TABLE, a déjà été calculée au moment où on rencontre cette instruction: donc en mode d’exécution pas à pas (PAR_LOT=’NON’). **Remarque lexicale :** Les noms de concepts ne doivent pas dépasser 8 caractères. Les caractères alphanumériques sont licites (lettres minuscules et majuscules et chiffres non placés en première position) ainsi que le underscore ‘_’. La casse est importante: les concepts «MAIL» et «Mail» pourront être utilisés dans un même fichier de commande et seront considérés comme différents … c’est toutefois déconseillé pour la lisibilité du fichier! Opérations possibles -------------------- La structure du langage de commande se présente sous la forme d'une suite linéaire d'instructions. Outre les instructions python autres que des commandes Aster, dont il n’est pas question pour le moment, trois natures d'instructions (ou de commandes) sont disponibles : * l'opérateur qui effectue une action et qui fournit un conceptproduit d'un type prédéfini exploitable par les instructions suivantes dans le jeu de commandes, * la procédure qui effectue une action mais ne fournit pas de concept, * la macro-commande qui génère une séquence d’instructions des deux types précédents et qui peut produire zéro, un ou plusieurs concepts. Typiquement, un opérateur sera une commande d’affectation ou de résolution, une procédure sera une commande d'impression (dans un fichier). Du point de vue syntaxique un opérateur se présente sous la forme : .. code-block:: text nomconcept = opérateur( arguments . . . ) Alors qu'une procédure se présente sous la forme : .. code-block:: text procédure( arguments . . . ) La syntaxe d'un opérateur ou d'une procédure est décrite dans le paragraphe suivant. Règles sur le concept produit par un opérateur ---------------------------------------------- Principe de base ~~~~~~~~~~~~~~~~ A chaque exécution d'un opérateur, celui-ci fournit un nouveau concept produit du type prédéfini dans le catalogue de commande. *Les concepts apparaissant en argument d'entrée des commandes, ne sont pas modifiés.* Concept produit et concept réutilisé ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ On appelle concept réutilisé, un concept qui étant produit par un opérateur, est modifié par une nouvelle occurrence de cet opérateur ou par un autre opérateur. L'utilisation d'un concept réutilisé n'est possible, comme dérogation du Principe de Base qu'à deux conditions : * autorisation donnée, par le catalogue et la programmation de la commande, d'utiliser des concepts réutilisables pour l'opérateur: l’attribut reentrant du catalogue vaut ‘o’ ou ‘f’, * demande explicite de l'utilisateur de la réutilisation d'un concept produit par l’attribut reuse=nom_du_concept dans les arguments des commandes qui le permettent. Vérifications effectuées par le superviseur sur les concepts produit ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ * Concept produit respectant le principe de base : Le superviseur vérifie que le nom du concept produit n'est pas déjà attribué par une des commandes précédentes, en particulier par une commande d'une exécution précédente dans le cas d'une POURSUITE ou d’un INCLUDE. * Concept utilisé en réutilisation : Le superviseur vérifie que : * le nom du concept produit est déjà bien attribué. * l'opérateur est bien habilité à accepter des concepts réutilisés, * le type du concept est conforme au type de conceptproduit par l'opérateur. Exemples commentés : .. code-block:: text DEBUT ( ) concept=opérateur ( ) # (1) est correct : on défini le concept, concept=opérateur ( ) # (2) est incorrect : on essaie de redéfinir le # concept mais sans le dire, concept=opérateur (reuse = concept ) # (3) est correct, si l'opérateur accepte des # concepts existants et si le type est # cohérent; c’est incorrect si l'opérateur # ne les accepte pas. FIN ( ) De fait un concept ne peut être créé qu’une seule fois: ce qui signifie apparaître à gauche du signe=(égal) sans que reuse soit employé dans les arguments de la commande. Dans le cas d’une ré-utilisation, préciser à nouveau le nom du concept derrière l’attribut reuse est redondant; d’autant plus que le superviseur vérifie que les deux noms de concept sont identiques. **Remarque:** *On peut détruire un concept, et donc ré-utiliser son nom ensuite.* Corps d'une commande -------------------- Introduction ~~~~~~~~~~~~ Le corps d'une commande contient la partie "variable" de la commande. Les déclarations sont séparées par des virgules et à part l’attribut reuse mentionné plus haut, elles sont toutes de la forme : [mot_clé] = [argument] Le mot clé est nécessairement un mot clé de la commande en cours, déclaré dans le catalogue de celle-ci. Mot clé ~~~~~~~ Un mot clé est un identificateur formel, c'est le nom de l'attribut recevant l'argument. Exemple : MATRICE = ... **Remarques syntaxiques :** * *l'ordre d'apparition des mots clés est libre, il n'est pas imposé par l’ordre de déclaration dans les catalogues,* * *les mots clés ne peuvent excéder 16 caractères (mais seuls les 10 premiers caractères sont signifiants).* Il existe deux types de mots clés: les mots clés simples et les mots clés facteurs qui diffèrent par la nature de leurs arguments. Argument d’un mot clé simple ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Le type des arguments ^^^^^^^^^^^^^^^^^^^^^ Les types de base reconnus par le superviseur sont : * les entiers, * les réels, * les complexes, * les textes, * les logiques, * les concepts, * ainsi que les listes de ces types de bases. Les entiers et les réels correspondent exactement aux types équivalents en python. * Mot clé simple facultatif attendant un réel: .. code-block:: text Catalogue : VALE = SIMP( statut=’f’ , typ = ‘R’ ) , Fichier de commandes : VALE = 10. , * Mot clé simple facultatif attendant un entier: .. code-block:: text Catalogue : INFO = SIMP( statut=’f’ , typ = ‘I’ ) , Fichier de commandes : INFO = 1 , La représentation du type complexe estun "tuple" python contenant une chaîne de caractères indiquant le mode de représentation du nombre complexe (parties réelle et imaginaire ou module-phase) puis les valeurs numériques. .. code-block:: text Catalogue : VALE_C = SIMP( statut=’f’ , typ = ‘C’ ) , Fichier de commandes : VALE_C = ( ‘RI’ , 0.732 , -0.732 ) , Fichier de commandes : VALE_C = ( ‘MP’ , 1. , -45. ) , Les deux notations sont strictement équivalentes. En notation ‘MP’, la phase est en degrés. Le type texte est déclaré entre simples cotes. La casse est respectée. Cependant, quand un mot clé doit prendre une valeur dans une liste prédéfinie dans le catalogue, l’usage veut que cette valeur soit aujourd’hui toujours en capitales. .. code-block:: text Catalogue : TOUT =SIMP( typ=‘TXM’,into=(‘OUI’,’NON’)) , Fichier de commandes : TOUT = ‘OUI’ , La casse est importante et, dans le contexte ci-dessus, la ligne de commande suivante échouera: .. code-block:: text Fichier de commandes : TOUT = ‘oui’ , Le type logique n’est pas utilisé aujourd’hui dans le catalogue de commandes. Le concept est déclaré simplement par son nom, sans cotes ni guillemets. Notion de liste ^^^^^^^^^^^^^^^ **Attention** : Le mot «liste» est ici un abus de langage. Il ne s’agit pas du type «liste» de python mais plutôt de tuples, au sens de python: les différents items sont déclarés entre une parenthèse ouvrante et une parenthèse fermante; ils sont séparés par des virgules. Les listes sont des listes homogènes, c'est à dire dont les éléments sont du même type de base. Tout type de base peut être utilisé en liste. Exemples de liste : .. csv-table:: "liste d'entiers", "(1, 2, 3, 4)," "liste de texte", "( 'ceci', 'est', 'une', 'liste', 'de', 'texte')," "liste de concepts", "( resu1, resu2, resu3 )," Facilité d'emploi : Il est admis qu'une liste réduite à un élément puisse être décrite sans parenthèse. Exemple de liste erronée : Liste hétérogène d'entier et de réel .. code-block:: text (1, 3, 4.) Mot clé facteur ~~~~~~~~~~~~~~~ Certaines informations ne peuvent être données globalement (en une fois dans la commande), il est donc important de prévoir la répétition de certains mots clé, pour pouvoir leur affecter des arguments différents. Le mot clé facteur offre cette possibilité ; sous un mot clé facteur, on trouvera donc un ensemble de mots clé (simples), qui pourront être utilisés à chaque occurrence du mot clé facteur. Cela permet en outre d’améliorer la lisibilité du fichier de commandes en regroupant des mots clés qui partagent un sens commun: par exemple les différents paramètres d’un même matériau. Contrairement au mot clé simple, le mot clé facteur ne peut recevoir qu’un seul type d’objet: l’objet superviseur «_F», ou une liste de celui-ci. Soit le mot clé facteur n’a qu’une seule occurrence et on peut écrire par exemple, au choix: .. code-block:: text IMPRESSION = _F( RESULTAT = resu, UNITE = 6), ou IMPRESSION = ( _F( RESULTAT = resu, UNITE = 6), ), Dans le premier cas, le mot clé facteur IMPRESSIONreçoit un objet _F, dans l’autre, il reçoit un singleton. Attention à la virgule; en python, un tuple à un élément s’écrit: (élément,) Soit le mot clé facteur a plusieurs occurrences, deux dans cet exemple: .. code-block:: text IMPRESSION = ( _F( RESULTAT = resu1, UNITE = 6), _F( RESULTAT = resu2, UNITE = 7) ), Le nombre d'occurrence (minimum et/ou maximum) attendu d'un mot clé facteur est défini dans le catalogue de commandes. **Notion de valeur par défaut** Il est possible de faire affecter par le superviseur des valeurs par défaut. Ces valeurs sont définies dans le catalogue de commandes et non dans le FORTRAN. Il n'y a pas de distinction du point de vue de la routine associée à la commande entre une valeur fournie par l'utilisateur et une valeur par défaut introduite par le superviseur. Ceci apparaît lors de l'impression des commandes utilisateur par le superviseur dans le fichier de messages : toutes les valeurs par défaut apparaissent dans le texte de commande, si elles n'ont pas été fournies par l'utilisateur **Rappel** : on ne peut pas donner de valeur par défaut à un concept.