\documentclass[12pt]{report}
\usepackage[french]{babel} 
\usepackage[latin1]{inputenc}
\usepackage[]{fontenc}
\usepackage{psfig,epsf}
\usepackage{a4,fancyheadings}  

\title{GIBIANE - CASTEM2000} 
\author{\vspace*{3cm} \\SEMT/LAMS\\ 
 T. Charras}
\date{\ }
\addtolength{\headheight}{2.5pt}
%\setlength{\oddsidemargin}{0.cm}
%\setlength{\evensidemargin}{0.cm}
%\setlength{\topmargin}{0.cm}
%\setlength{\marginparwidth}{0.cm}
%\setlength{\marginparsep}{0.cm}
%\setlength{\textwidth}{17.cm}
%\setlength{\textheight}{24.cm}
%\font\dmt=dmt
\pagestyle{fancy}
          
\lhead{}
\chead{Gibiane Objet - Castem2000}
\rhead{}

\lfoot{}
\cfoot{}
\rfoot{- \thepage  \ -}


\begin{document} 

\maketitle
\tableofcontents 
\newpage
% \flushleft
\chapter{Introduction}

Castem2000 est le fruit de plus de vingt ans de développement de
programmes de calcul par la méthode des éléments finis (résolution
d'équations aux dérivées partielles sur un domaine fini). Il tente
d'incorporer toutes les étapes nécessaires pour mener à bien une étude
par éléments finis, du maillage au post-traitement. Son champ
d'application privilégié est la mécanique mais il traite aussi bien de
la thermique, de l'hydraulique ou de l'éléctromagnétisme.

Castem2000 est fondé sur un concept OPERATEUR-OPERANDES et se différencie
en cela des programmes classiques d'éléments finis. Les opérateurs
sont des outils qui agissent sur des objets spécifiques.

Dans le cadre du projet ELAN, GIBIANE a intégré les concepts modernes
d'objets et de méthodes. Une approche de Castem2000 à travers le
concept de : "méthodes qui s'appliquent à des objets" est maintenant
possible.

Il était donc nécessaire de mettre à jour la présentation de GIBIANE.

\chapter{ Presentation générale de Castem2000}

\section{Structure de Castem2000}

Quand on démarre un micro-ordinateur, celui-ci lance son programme
d'exploitation (par exemple UNIX) et se met en
attente des commandes utilisateurs. Le programme d'exploitation a une
structure de "Data Flow Control" c'est à dire que ce sont les données
utilisateur qui orientent le déroulement des actions, celles-ci
n'ayant a priori aucun ordre pré-établi.

Cette structure a été choisie pour Castem2000 et cela 
nécéssite un superviseur de commandes qui soit capable de :\\
\begin{itemize}
\item  lire une commande utilisateur
\item reconna\^\i tre l'action à faire
\item donner la main à l'opérateur et instaurer un dialogue avec
lui pour lui fournir les arguments qu'il réclame et récupérer les
résultats qu'il fournit
\item attendre une nouvelle commande
\end{itemize}
\vspace{1mm}
La syntaxe générale de UNIX est : 

\vspace{5mm}
{\hspace{2cm} OPERATEUR OPERANDE1 OPERANDE2 ... } 
\vspace{5mm}

Celle de Castem2000 est :  
\vspace{5mm}

{\large \hspace{2cm} {\bf RESULTAT = OPERATEUR OPERANDES ; } }
\vspace {5mm}

Par exemple pour copier un fichier sur un autre il faut sous UNIX
écrire : 

\vspace{5mm}
{\hspace{2cm} CP FICH1 FICH2  } 
\vspace{5mm}

alors que dans la syntaxe de Castem2000 nous devons écrire : 
\vspace{5mm}

 {\hspace{2cm}{\large {\bf FICH2 = COPIER FICH1; }} } 
\vspace {5mm}

L'action complète dans Castem2000 est décomposée en trois parties :
\begin{enumerate}
\item 
 Lecture de la commande par le superviseur qui donne le contr\^ole
à l'opérateur COPIER.
\item 
 COPIER demande au superviseur les opérandes (ici FICH1) puis il
exécute le travail et rend au superviseur son résultat.
\item 
 Le superviseur traite la commande "FICH2= résultat". Il affecte
le nom FICH2 à ce résultat et le place dans la base des objets déjà crées et
nommés.
\end{enumerate}
\section{Les objets dans Castem2000}
Comme nous l'avons vu UNIX est un système d'exploitation de gestion
des fichiers, or en éléments finis il s'agit de maillages, de
rigidités, de champs de vecteurs déplacements, de champs
magnétiques.... Les entités ou objets que reconna\^\i tra le
superviseur sont de natures(types) différentes.

Pour travailler intelligement, on se dote de structures complexes :
\begin{enumerate}
\item Les premières sont issues  des entités
physiques à représenter : MAILLAGE, CHPOINT (champs définis sur les noeuds du
maillage), MCHAML (Champs définis sur les éléments finis), CHARGEMENT
(description d'un chargement variant dans le temps et dans l'espace)...
\item les deuxième ont un r\^ole plus mathématiques : RIGIDITE (qui
sert pour toutes les matrices), EVOLUTION (décrit l'évolution d'une
quantité en fonction d'une autre), NUAGE (généralisation de
l'EVOLUTION)...
\item Les derniers sont utilitaires : TABLE, ENTIER, FLOTTANT, MOT...
\end{enumerate}

Ces structures sont les objets de Castem2000. Les instanciations de
ces types d'objets sont {\bf nommées} ce qui permet de les manipuler
individuellement. Les instanciations sont aussi appelés "objets de
Castem2000".
 
Un objet est une {\bf collection prédéfinie} d'informations. Ainsi un opérateur
qui peut travailler sur un type d'objet n'a pas à se soucier de la provenance de
l'objet mais seulement de son type qui lui assure toute une série d'informations
dans un format prédéfini. Il en découle ainsi l'indépendance des
opérateurs entre eux. 

Seul l'opérateur manipule les objets et en crée de nouveaux, le
superviseur n'est là que pour lui donner la main et lui fournir les
opérandes qu'il réclame. 

La syntaxe générale et le concept d'objet de Castem2000 sont très
intuitifs, ils correspondentbien à une vision "algébrique" de la
modélisation (des produits comme MATLAB ou MATHEMATICA ont une approche
similaire). 


\subsection{Liste des règles du superviseur}

\begin{itemize}
\item Le point virgule signale la fin de la commande et demande au superviseur
de lancer l'analyse puis l'exécution.

\item La commande est analysée seulement sur les 72 premiers caractères de
chaque ligne (un reste des antiques cartes perforées!).
\item Une commande peut tenir sur plusieurs lignes
 et il peut y avoir plusieurs commandes par lignes.
 \item
A priori les caractères minuscules sont remplacés par des majuscules. Les
quotes, encadrant des caractères, marquent la définition d'une cha\^\i ne de
caractères à prendre sans modification.

\it
\begin{enumerate}
\item "res1 = mot 'AB3ef' "; et  " res2 = mot AB3ef ";  ne produisent pas le m\^eme
 résultat, la deuxième instruction est égale à  : " res2 = mot AB3EF "  
\item dans la séquence :  " X = 5;  Y = x + 3 ; "  x est traduit en X et Y
vaudra 8
\item " x = 5 ; y = X + 3 ; " produit aussi Y égal 8 car le nom des objets est
toujours transcodé en majuscule.
\item Le nom d'un objet ne peut pas faire plus de 8 caractères.
\end{enumerate}
\rm

\item
Le caractère blanc est le séparateur universel. D'autres caractères sont parfois
des séparateurs, par exemple + - *. Néanmoins nous ne saurions trop conseiller
d'utiliser systématiquement des blancs entre les données afin d'éviter tout
risque d'erreur surtout avec les symboles plus "+", moins "-" et point ".". 
 Par exemple le point "." sert de virgule  flottante et de séparateur des
 indices des objets "tables" il ne faut donc pas confondre  TAB.1.2 et TAB . 1 .
 2 , dans le premier cas il s'agit de la table TAB et de son indice flottant
 valant 1.2 et dans l'autre de la table TAB et de son indice 1 qui lui m\^eme
 pointe vers une table dont on prend l'indice 2.
 
 \item Un nom d'objet a au plus huit caractères alphanumériques, au delà toute cha\^\i ne de
 caractères devient un objet de type "MOT" qui n'a pas de nom. Ce nom
 ne doit pas pouvoir \^etre interprété comme une constante numérique (par
exemple 1e5).
Le type d'un objet est une cha\^\i ne de caractères de 8 lettres ou
moins (PROCEDUR, CHARGEME, CHPOINT, EVOLUTIO, MOT...).
\item
Aucun nom n'est réservé, m\^eme ceux des opérateurs peuvent \^etre
surchargés (attention, c'est une source d'erreur).
 
 \item 
L'instruction est lue de gauche à droite et est exécutée dans ce m\^eme ordre
sans notion de hiérarchie entre opérateurs. La notion de calcul en cha\^\i ne
appara\^\i t ici. Elle permet de ne pas nommer les résultats intermédiares.

\it
\begin{itemize}
\item
 x = 3 + 5 * 8 ; produit x égal 64 
\item  
 y = 3 + 5 ; x = y * 8 ;  produit aussi x égal 64 mais le résultat y égal 8 est
 conservé 

\end{itemize}
\rm
\item 

\end{itemize}

\section{Quelques remarques sur le fonctionnement}
\subsection{Recherche du nom de l'opérateur}

Le superviseur lit la commande, située après le signe =, jusqu'à ce qu'il
rencontre une cha\^\i ne de caractères (donc ni entier ni flottant) qui
 ne correspond pas à un objet nommé.
Il interrompt alors le décodage de la ligne et crée un objet de type MOT.
Si cette cha\^\i ne ne fait pas plus de huit caractères il lui donne un nom qui est
égal au contenu de la cha\^\i ne, le nom et le contenu sont identiques.
 Ensuite
le superviseur vérifie si les quatres premières lettres de ce mot correspondent
au nom d'un opérateur. Si tel est le cas, le superviseur lui donne le
 contr\^ole sinon il exécute le signe égal (=), c'est à dire qu'il affecte
des noms aux résultats. Une fois donné le contr\^ole à un opérateur, le
superviseur attend que celui-ci ait fini son travail.

Nous ne parlerons pas ici du traitement des "procédures" qui ressemble à
celui des opérateurs.

\vspace{5mm}
{\it  Remarque : Le message d'erreur dans le signe = du type "Il y a un objet en
trop par rapport aux noms à affecter" est souvent d\^u à une mauvaise orthographe
de l'opérateur ou au fait qu'il est précédé par un mot. C'est pour cette raison
qu'il est préférable de toujours mettre le nom de l'opérateur avant les opérandes de type
"MOT". Ainsi il faut écrire : " EGA MOT1 MOT2 " et non pas " MOT1 EGA MOT2"}

\subsection{Position des opérandes}

Nous avons déjà parlé de la position relative du nom de l'opérateur et des
opérandes, mais il faut, de temps en temps, faire aussi attention à la position
des opérandes les uns avec les autres.

Quand un opérateur demande au superviseur de lui fournir des opérandes, celui-ci
parcourt la liste des opérandes jusqu'à ce qu'il en trouve un du bon type et le
fournit à l'opérateur. Cette recherche d'un objet du bon type s'arr\^ete si le
superviseur rencontre un "MOT", ceci permet de garder un caractère local aux
données et de ne pas mélanger les données de deux opérateurs successifs.

Les opérandes d'un opérateur qui ne sont pas des MOTS  peuvent donc \^etre mis
dans n'importe quel ordre s'ils sont de types différents. Si plusieurs opérandes
du m\^eme type sont  appelés, l'ordre peut bien évidemment avoir de
l'importance, par exemple pour l'opérateur de soustraction.

\vspace{5mm}
{\it Remarque : quand un opérateur a des données obligatoires et des données
facultatives déclarées à l'aide de mots-clés il peut \^etre nécessaire de placer les données
obligatoires avant les facultatives. La notice donne toujours un ordre
qui fonctionne }


\section{Conclusion du premier chapitre}

Ces quelques règles sont suffisantes pour posséder un superviseur de commandes
de niveau élémentaire qui fonctionne parfaitement. Cependant il est possible de
rendre plus confortable ce langage de commande. Au fur et à mesure des besoins,
ce langage a été amélioré et il est devenu , peu à peu, un langage plus 
complet qui a été baptisé "GIBIANE".

\chapter{Le langage de données :  GIBIANE}
\section{Améliorations de convivialité}
\subsection{Commentaires}
Il est possible de commenter un jeu de données en introduisant des lignes 
de commandes qui
ont comme premier caractère l'étoile "*". Le superviseur lit les lignes 
 et passe aux  suivantes.
\subsection{résultats multiples}
Un opératuer peut fournir plussieurs résultats et le superviseur doit leur
affecter à chacun un nom. la syntaxe devient :

\vspace{5mm}
\begin{verbatim}
   RES1 RES2 RES3 .. = OPERATEUR OPERANDES ;
\end{verbatim} 
\vspace{5mm}

Par exemple pour initialiser plusieurs variables il est possible d'écrire :

\vspace{5mm}
\begin{verbatim}
   A B C D E = 1 2 3 4 5 ; 
\end{verbatim} 

\vspace{5mm}

Cette séquence est identique à :

\vspace{5mm}
 
\begin{verbatim}
   A=1 ; B=2; C=3 ; D=4 ; E=5 ; 
\end{verbatim} 
\vspace{5mm}

En fait, très peu d'opérateurs fournissent plusieurs résultats, par contre, cela
arrive plus souvent aux 
procédures que nous verrons plus tard.  
\subsection{Traitement des parenthèses}
Pour s'affranchir de l'exécution des commandes de gauche à droite il est
possible de préciser l'ordre d'exécution à l'aide de parenthèses. La règle est
d'effectuer d'abord les parenthèses en commençant à chaque fois par la plus
interne qui se trouve le plus à gauche. Cela revient à effectuer un groupe entre
parenthèses dès qu'on  rencontre la parenthèse fermante. Il peut y avoir autant
de parenthèses emboitées que nécessaires. Exemples :

\vspace{5mm}
\begin{verbatim} 
   X   = 3 + ( 5 * 8 ) ;                           ---> X = 43   
   LI  = ( 0 0 0 ) DROIT 10 ( 5 0 0 ) ;
   SUR = TRANS 5  ( (0 0 0 ) DROIT 10 ( 5 0 0 ) )  ( 0 10 0 );
   A   = ( 1 + ( 2 * ( 8 - ( 5 - 3))))             ---> A = 13 
\end{verbatim} 

\section{Addition au langage, structuration des commandes}

Le travail fait pour améliorer GIBIANE n'a pour but ni d'en faire un langage
sophistiqué avec de nombreuses possibilités ni d'en faire un vrai langage de
programmation. Il essaye plut\^ot de rendre le
langage plus souple en introduisant une exécution non linéaire
 des commandes.{\it Les additions aux langages qui suivent sont traitées à
l'aide d'opérateurs et seuls les quatre premières lettres suffisent.}
\subsection{ Exécution alternative : SI }
L'opérateur "SI" permet, suivant la valeur de l'objet de type LOGIQUE qui 
le suit, d'exécuter une séquence de commandes ou une autre. Les deux syntaxes
suivantes sont permises.

\vspace{5mm}
\bf 
\begin{verbatim} 
   SI    LOG1 ;                      |
       suite1 de commandes           | si LOG1 a la valeur VRAI      
   SINON;                            | suite1 est exécutée sinon 
       suite2 de commandes           | c'est suite2
   FINSI;                            |
   	  
\end{verbatim}
   ou bien
   
\begin{verbatim} 
   SI   LOG1  ;                      |  La séquence suite1 est 
       suite1 de commandes           |  exécutée si LOG1 est 
   FINSI;                            |  VRAI 
\end{verbatim}  
 
\vspace{5mm}
\it
Remarque : le logique  LOG1 peut bien évidemment \^etre le résultat d'un calcul
et l'on rencontre souvent les formes :
\rm
\vspace{5mm}

\begin{verbatim} 
 SI (  AA EGA BB) ; ...
 
 SI ( ( AA EGA BB ) ET ( CC EGA DD) ); ....
\end{verbatim}

\subsection{Exécution répétitive : REPETER}

L'opérateur "REPETER" permet de définir une séquence de commandes à exécuter
autant de fois que nécessaire.
\subsubsection{Syntaxe de REPETER}

\vspace{5mm}
\bf 
\begin{verbatim} 
   REPETER  NOMBOUCL  NFOIS;
         ...   
         ...
      suite de commandes
         ...
   FIN  NOMBOUCL ;
   
\end{verbatim}
\vspace{5mm} 
\rm  

La suite de commandes comprise entre REPETER et FIN sera ainsi répétée NFOIS.
La séquence est toujours exécutée au moins une fois. Il est permis de mettre des
SI à l'intérieur des boucles et réciproquement.
 
Le nombre NFOIS est facultatif, s'il n'est pas précisé la boucle se répéte
infiniment et il faut faire appel à un autre mécanisme pour en sortir.  
\subsubsection{QUITTER une séquence REPETER}
Pour sortir d'une séquence REPETER, soit parce qu'elle était infinie, soit de
manière anticipée, on peut utiliser l'opérateur QUITTER. La structure logique
des données GIBIANE devient :

\vspace{5mm} 
\begin{verbatim} 
   REPETER  NOMBOUCL  NFOIS;
         ...   
         ...
         SI LOG1 ; QUITTER NOMBOUCL ; FINSI;
         ...
   FIN  NOMBOUCL ;
   
\end{verbatim}
\vspace{5mm} 

Aprés l'instruction QUITTER l'exécution reprend à la commande située derrière
FIN NOMBOUCL;
\subsubsection{ITERER une séquence REPETER}

A l'intérieur d'une séquence REPETER, on peut sauter la partie finale de la
séquence de commandes en utilisant l'opérateur ITERER. Dans ce cas l'exécution
de commandes continue à la commande FIN NOMBOUCL, c'est-à-dire que la séquence
est répétée  si  le compteur n'a pas atteint NFOIS. 

Exemple :

\vspace{5mm} 
\begin{verbatim} 
   I = 0 ;
   REPETER  NOMBOUCL  4;
       I = I + 1;   
       SI ( I EGA 2 ) ; ITERER NOMBOUCL ; FINSI;
       MESSAGE ' I VAUT ' I ;  
   FIN  NOMBOUCL ;
   
\end{verbatim}
\vspace{5mm} 

Cette séquence produit les impressions suivantes : 

\begin{verbatim}
   I VAUT  1
   I VAUT  3 
   I VAUT  4 
\end{verbatim}      

\section{Macro commandes : les PROCEDURES}

Une procédure sert à regrouper une séquence d'instructions en lui donnant un nom. Cette
séquence de commandes  pourra \^etre
invoquée et exécutée en l'appelant par son nom. Un tel regroupement se fait dans
un objet de type PROCEDURE. Dès que l'on dispose d'un objet nommé de
type PROCEDURE, son utilisation
se fait de la m\^eme façon que les opérateurs à la différence près que les
procédures sont invoquées par leur nom complet  (sans faute
d'orthographe), tandis que, pour un opérateur, seul les quatre premières lettres
comptent.
\subsection{Déclaration d'une procédure}
La procédure est un regroupement de commandes. Avant de l'utiliser, il faut la
créer et la nommer par l'opérateur "DEBPROC" (DEBut de PROCédure) et c'est seulement lors
de son appel ultérieur qu'elle sera exécutée. La syntaxe en est la suivante :

\vspace{5mm} 
\begin{verbatim} 
   DEBPROC  NOMPROC  ARG1*TYP1  ARG2*TYP2 ...;
         ...
         ...
      suite de commandes    
         ...
         ...
   FINPROC  RES1  RES2  ....  ;  
\end{verbatim}
\vspace{5mm}  

La procédure NOMPROC vient d'\^etre définie. Elle admet des arguments d'entrée
ARG1,ARG2... et des arguments de sortie RES1,RES2... Les arguments d'entrée
peuvent avoir un type qui est précisé par TYP1,TYP2...

Une procédure est une structure semi-ouverte :
\begin{itemize}
\item  elle a  la connaissance
des objets externes m\^eme s'ils ne sont pas passés en arguments 

\item  elle ne peut pas modifier les objets externes 

\item elle ne transmet au monde externe que ses arguments de retour RES1,RES2..

\item les objets définis dans la procédure et qui ne sont pas des arguments de
retour sont perdus dès la sortie de la procédure.
\end{itemize}

\it
Nous conseillons de passer en arguments les objets dont la procédure aura
besoin, à l'exception des objets de type PROCEDURE. 
\rm

\subsection{Exécution d'une procédure}

Pour utiliser la procédure il suffit de l'invoquer par son nom comme un
opérateur classique. 

\vspace{5mm}
Exemple complet :

\vspace{5mm}
\begin{verbatim} 
   DEBPROC  MODULO  II*ENTIER  JJ*ENTIER;
     SI( JJ EGA 0) ; MESSAGE ' NOMBRE ZERO INACCEPTABLE';.... ;FINSI;
     KK = II / JJ;   
     MOD = II - ( KK * JJ) ;
   FINPROC  MOD ;
   
   X = 35 ; Y = 6 ; KK = 18;
   Z = MODULO X Y ;
   MESSAGE ' Z VAUT ' Z 'KK VAUT ENCORE ' KK;   
\end{verbatim}
\vspace{5mm} 

Cette séquence produit le message :

\vspace{5mm}
\begin{verbatim} 
    Z VAUT 5  KK VAUT ENCORE 18 
\end{verbatim}
\vspace{5mm} 

On remarque bien que la définition de KK à l'intérieur de la procédure n'affecte
pas sa valeur à l'extérieur. On aurait pu provoquer une erreur d'exécution de la
procédure si avant de l'appeler on avait surchargé une valeur à SI. Par exemple, en
supposant la m\^eme définition de la procédure MODULO la séquence suivante
provoque une erreur.

\vspace{5mm} 
\begin{verbatim} 
    SI = 32; X = 35 ; Y = 6 ; KK = 18;
    Z = MODULO X Y ;
\end{verbatim}
\vspace{5mm} 

En effet à l'intérieur de la procédure la commande : "32  FAUX"  n'a pas 
de sens. Pour se prémunir du surchargement des noms d'opérateurs dans les
procédures, il suffit de les mettre entre quotes, afin que l'analyseur 
de syntaxe
les considère toujours comme des mots et non comme un nom d'objet ( par chance,la
plupart du temps cet objet n'existe pas. Une procédure du domaine 
public à donc
tout intér\^et à \^etre écrite comme suit :  
     

\vspace{5mm} 
\begin{verbatim} 
   'DEBPROC'  MODULO  II*'ENTIER'  JJ*'ENTIER';
     'SI'( JJ 'EGA' 0) ; 'MESSAGE' ' NOMBRE ZERO INACCEPTABLE';.... ;'FINSI';
     KK = II / JJ;   
     MOD = II - ( KK * JJ) ;
   'FINPROC'  MOD ;
\end{verbatim}
\vspace{5mm} 

Dans ce cas là, aucune mésaventure ne peut arriver. A la lecture de cette
procédure, on remarque des points de suspension. Il y aurait besoin ici d'un
opérateur pour sortir de la procédure. 

\subsection{Sortie anticipée d'une procédure} 

Pour sortir immédiatement d'une procédure, il faut utiliser l'opérateur QUITTER
qui fait continuer l'exécution à la commande FINPROC ...

Il faut préciser le nom de la procédure que l'on veut quitter (exemple
paragraphe suivant).

\subsection{Arguments différés, arguments facultatifs}

Suivant le déroulement logique de la procédure, il peut \^etre nécessaire
d'avoir d'autres informations, l'opérateur ARGUMENT permet en cours de procédure
d'appeler de nouveaux arguments. Prenons l'exemple suivant d'une procédure qui
additionne autant d'entiers qu'on lui en fournit.


\vspace{5mm} 
\begin{verbatim} 
   'DEBPROC' ADDIT I*'ENTIER' J*'ENTIER' ;
* petite procédure pour additionnée N entiers
      K = I + J ; I = 24;
      'REPETER' BOU;
         'ARGUMENT' L/'ENTIER';
	  'SI' ( 'EXISTE' L) ;
	      K = K + L ;
	  'SINON';
	      'QUITTER' ADDIT;
	  'FINSI';
      'FIN'  BOU;
   'FINPROC' K ;
   
* exemple d'utilisation 

  A = 2; B = 5 C = 7 ; 
  X = ADDIT A B 18 C -4;
* le résultat attendu est : X = 28 et  A est toujours égal à 2 
  X = ADDIT 2  ( ADDIT 5 8 9 )  6 ;
* le résultat attendu est : X = 30;	       
\end{verbatim}
\vspace{5mm} 

Pour rendre facultatif un argument, il faut remplacer l'étoile qui sépare le nom
de l'argument de son type par un slash ("/"). Ceci peut \^etre fait soit pour
les opérandes de DEBPROC soit pour ceux de ARGUMENT. L'opérateur EXISTE permet
de savoir si un objet, passé en argument facultatif, a été trouvé. Il renvoie
alors un logique VRAI ou FAUX.

\subsection{Non-initialisation des variables}

Comme nous l'avons vu, la procédure étant semi-perméable, ell va chercher dans
le monde externe la valeur des objets qu'elle utilise. Pour éviter cette
recherche il faut faire commencer 
le nom de l'objet par un point d'exclamation ("!"). Examinons les deux
procédures suivantes dans lesquelles une erreur de frappe c'est glissée:


\vspace{5mm} 
\begin{verbatim} 
   'DEBPROC'  PASBELLE  II*'ENTIER'  JJ*'ENTIER';
      AD  = II + JJ;
      MU  = II * JJ ;     
      RES = MU - ADD;
* la bonne ligne est : RES = MU - AD; 
   'FINPROC'  RES ;
   
   'DEBPROC'  JOLIE  II*'ENTIER' JJ*'ENTIER';
       !AD = II + JJ ;
       !MU = II * JJ ;
       !RES = !MU - !ADD;
* la bonne ligne est : !RES = !MU - !AD; 
   'FINPROC'  MOD ;
   
* utilisons maintenant ces procédures 

    ADD = 456 ; !ADD = 456 ;  K = 5  ; I =  3 ;
    X = PASBELLE  K I ; 
    Y = JOLIE  K I ;
\end{verbatim}
\vspace{5mm} 

L'appel à PASBELLE fournit un résultat qui vaut  -441 ! Alors que l'appel à
JOLIE provoque une erreur. Pour les gens très courageux, il est bon de donner un
nom commençant par \hspace{1mm} ! pour toutes les variables internes aux procédures, il en
résulte  une plus grande sureté.

\subsection{Résultats en cours de procédure}
Tout comme l'opérateur ARGUMENT permet de lire des arguments en cours de
procédure, l'opérateur RESPRO (RESultat PROcédure) permet de fournir des
résultats en cours de procédure en plus de ceux donnés par  l'opérateur FINPRO.
\subsection{Les procédures de Castem2000}

Un grand nombre de procédures sont fournies avec le logiciel, par exemple
l'algorithmique des calculs non-linéaires est piloté par les procédures
PASAPAS, INCREME, TRANSNON. Ces procédures font parties intégrantes de
Castem2000 et un message appara\^it si elles sont surchargées par
l'utilisateur. D'autres procédures, celles commençant par une @, sont
fournies à titre d'exemple mais sans garantie d'une grande généralité ni
d'un bon fonctionnement. Toutes ces procédures sont regroupées dans un
fichier "GIBI.PROC"  de m\^eme que la notice est dans "GIBI.MASTER". 
\subsection{Les procédures personnelles }
L'utilisateur peut s'enregistrer, dans son espace de travail, des procédures
personnelles. Ces procédures surchargeant au besoin les procédures fournies avec
le logiciel. L'opérateur UTIL permet d'initialiser une bibliothèque de
procédures personnelles.
\vspace{5mm}
\begin{enumerate}
\item créer un fichier contenant les procédures. Chaque procédures doit \^etre
précédée par une ligne : \hspace{3mm} \$\$\$\$ NOMPROC  \hspace{5mm}
 où NOMPROC (en majuscules) est le nom de la procédure. Le
fichier doit se terminer par une carte : \hspace{3mm} \$\$\$\$
\item au besoin, suivre la m\^eme démarche pour les notices.
\item exécuter Castem2000 en lui demandant d'exécuter les commandes : \\ 
UTILISATEUR PROCEDURE 'nom du fichier des procédures' ; \\
(UTILISATEUR NOTICE 'nom du fichier des notices' ; \\
FIN;
\end{enumerate}

\vspace{5mm}
Cela étant fait, les exécutions suivantes de Castem2000 auront en mémoire
 les procédures standards et les procédures du fichier surchargeant
éventuellement les procédures standards.
\vspace{5mm}

\it
Remarque : La procédure INITIALE joue un r\^ole très particulier. Ce n'est pas
une procédure dans le sens qu'elle n'est pas encadrée par DEBPROC
 et FINPROC. Son autre particularité est d'\^etre appelée automatiquement en
 t\^ete de toute exécution de Castem2000. On peut ainsi se prédéfinir des
 variables ( E = 2.732..), des alias ( CIRCLE = MOT CERCLE; STIFF = MOT
 RIGIDITE ;...) ou m\^eme se prédéfinir systématiquement un maillage avec un
 modèle et un matériau etc... 
\rm
 
 \chapter{les OBJETS du langage}
Il existe quatre types d'objets qui ont un traitement spécifiques par GIBIANE, il
s'agit du "TEXTE qui est une cha\^\i ne de caractère à interpréter au moment de
son utilisation, de la TABLE qui est un objet fourre-tout, de l'OBJET qui,
 conformément aux spécifications des langages orientés objets, ne
 peut \^etre manipulé qu'à
travers des méthodes pour lesquelles sont créés des objets METHODE.

\section{Les TEXTES}
Un texte se déclare par l'opérateur TEXTE qui lit une cha\^\i ne de caractères. 

\vspace{5mm} 
\begin{verbatim} 
     TT = TEXTE  ' I + 2 '; 
\end{verbatim}
\vspace{5mm} 

Lors de l'utilisation, GIBIANE commence par le remplacer par son contenu et
seulement après fait l'analyse de la commande. 

\vspace{5mm} 
\begin{verbatim} 
* exemple d'utilisation 
   TT = TEXTE  ' I + 2 '; 
   I = 3 ; 
   XX = TT + 4 ;                             --> XX = 9 
\end{verbatim}
\vspace{5mm}         

L'utilisation des objets TEXTES est assez rare et nous ne la conseillons
pas. Il est parfois utile pour, dans
des procédures,
appeler  des opérateurs dont le nombre d'arguments est variable suivant le
contexte. On pourra ainsi passer en argument de l'opérateur soit un texte vide
soit un véritable objet. Par exemple :

\vspace{5mm}
\begin{verbatim} 
* exemple d'utilisation 
    TTT = TEXTE ' ';
    SI ( situation ou argument existe ) ; TTT =ARG3 ; FINSI;
    AA =  OPERATEUR ARG1 ARG2  TTT;
\end{verbatim}
\vspace{5mm}     

Dans le cas où l'opérateur n'attend que deux arguments le texte TTT est vide,
sinon TTT contient directement le troisième argument attendu.

\section{Les TABLES}

Une table est un sac qui peut contenir des objets de n'importe quel type. Les
objets contenus dans la table sont repérés par des indices. Ces indices sont
eux-m\^emes des objets de n'importe quel type.

Pour créer un objet de type TABLE on utilise l'opérateur TABLE. Les objets
servant d'indices d'une table sont séparés du nom de la table par un point
("."). 

L'objet TABLE est souvent utilisé pour regrouper des objets. Ces regroupements
permettent de définir une nouvelle structure d'informations, par exemple on peut
regrouper  toutes les données nécessaires à une procédure dans une table
dont les indices sont des mots qui donnent un sens aux objets qui sont dans la
table.

\vspace{5mm}
Exemple :
\vspace{5mm}

\begin{verbatim} 
* exemple d'utilisation 
   TA = TABLE;  I = 2  ; A = 'titi' ; Z = 2.25;
   TB = TABLE;
   TA . I = 28 ; TA. DEUXUNQUART = Z;
   TA . x = TB;  TA.25 = 8;
* comme x n'est pas défini il est pris comme un mot contenant " X " 

   TA.A = I + 4 ;                            
* TA.A doit donc etre égal à 6;

   Y = I + TA.I;
* ici Y vaut 30

   TB.3 = 36; TB . 2.25 = 4;  TB . 2 = TA;
   R = TB.2 . 2 + 5 ;  
* nous avons R = 33 (TB.2 vaut TA et TA.2 vaut 28, c'est la valeur 
* de l'indice qui compte et pas son nom)

    S = TB.2.25 ; T = TB . 2 . 25 ; 
*   S = 4  , T = 8   attention aux points décimaux
   U = TA.titi ;  V = TA . 'titi' ; W = TA . deuxunquart ;
*  l'instruction U =... provoque une erreur, V = 6  et W = 2.25
* (attention au changement minuscule-majuscule) 


  TA . ( TB . 2 ) = TA;
* attention TA se contient lui meme sous un indice qui est lui meme!
* cela permet l'écriture stupide suivante
  AE = TA.TA.TA.TA.TA.TA.TA.2;
* ce qui donne AE = 28 

\end{verbatim}
\vspace{5mm} 
     

\Large
Attention : L'objet TABLE est le seul objet du monde extérieur qu'une procédure
 peut modifier. Pour
autant il n'est pas besoin de la déclarée en tant que résultat de la procédure.
\normalsize
\vspace{5mm}
 
Un objet table créé dans une procédure doit \^etre donné en tant que résultat, 
si on veut l'utiliser à l'extérieur.
\section{Les METHODES}

Ces objets sont très ressemblants aux procédures. La seule différence est que
l'opérateur de création est DEBMETH ( au lieu de DEBPROC) et l'opérateur de
retour est FINMETH (au lieu de FINPROC). Sinon la méthode a un argument qui lui
arrive systématiquement; c'est l'objet sur lequel on applique la méthode. Cet
objet est reconnu dans la méthode par le caractère pourcent ("\%"). 

L'objet OBJET ressemble, quant à lui, à une table. Pour lui attribuer des
informations ( des objets) on fera précéder l'indice par le pourcent. Pour appliquer
une autre méthode sur l'objet on écrira aussi le pourcent suivi de la méthode.

\vspace{5mm}
Il existe trois  méthodes qui sont attribuées à tous les objets.

\begin{itemize}
\item la méthode METHODE
qui permet  d'affecter une méthode à un objet
\item la méthode HERITE qui permet à
un objet de prendre toutes les méthodes d'un autre objet
\item la méthode OUBLIER qui permet d'oublier une méthode
\end{itemize}
\section{Les objets de type OBJET}
La particularité de ces objets est d'\^etre uniquement manipulables par des objets
METHODE. L'opérateur OBJET est chargé de créer
un objet de type OBJET. Celui-ci est un collecteur, à la manière 
d'une table. Il faut préciser la classe de l'objet. Cette classe est
 un constructeur c'est-à-dire une méthode. C'est le premier accès à
l'objet. Il est donc nécessaire de définir dans ce constructeur les
entrées et les méthodes caractérisant la classe. Nous vous conseillons de lire
l'exemple suivant dans lequel les listings produits, encadrés par de "******", ont été introduits juste
après la commande  de liste e (voir le fichier
objet.dgibi qui est fournit avec Castem2000).

\vspace{5mm}
\begin{verbatim}
*
* creation of object of class "complex number".
*
* define first the constructor
DEBMETH COMPLEX;
%REA=FAUX;
%IMA=FAUX;
%METHODE SET_IMA  IMAG;
%METHODE SET_REA  REAL;
%METHODE GET_IMA  GIMAG;
%METHODE GET_REA  GREAL;
FINMETH;


* define standard methods of the class
DEBMETH IMAG  I*'FLOTTANT';
%IMA = I;
'SI' ('EGA'  ('TYPE'  %REA )  'FLOTTANT');
   %METHODE MODULE  MODUL;
'FINSI'; 
%OUBLIER SET_IMA;
FINMETH;


DEBMETH REAL RR*'FLOTTANT';
%REA = RR;
'SI' ('EGA'  ('TYPE'  %IMA )  'FLOTTANT');
   %METHODE MODULE  MODUL;
'FINSI';
%OUBLIER SET_REA;
FINMETH;


DEBMETH GIMAG ;
II = %IMA;
'SI' ( 'NEG' ( 'TYPE' II) 'FLOTTANT'); 
   'MESSAGE' 'The imaginary value is not yet defined';
   'ERREUR' 19;
'FINSI';
FINMETH II;

DEBMETH GREAL;
RR = %REA;
'SI' ( 'NEG' ( 'TYPE' RR) 'FLOTTANT'); 
   'MESSAGE' 'The real value is not yet defined';
   'ERREUR' 19;
'FINSI';
FINMETH RR;

DEBMETH MODUL;
* It is not neccessary to check that real and imaginary exist
AA= %REA* %REA + ( %IMA*%IMA) ** 0.5;
FINMETH AA;

*
* creation of a COMPLEX OBJET and use
*
COM = OBJET COMPLEX;
list com;

******************** start of  listing ************************
 Objet de type OBJET de pointeur 25089
         Indice                          Objet
      Type    Valeur                  Type   Valeur
 MOT       CLASSE                MOT       COMPLEX             
 METHODE   METHODE               MOT       METHODE             
 METHODE   HERITE                MOT       HERI                
 METHODE   OUBLIER               MOT       ANNU                
 MOT       REA                   LOGIQUE   FAUX                
 MOT       IMA                   LOGIQUE   FAUX                
 METHODE   SET_IMA               PROCEDUR       294            
 METHODE   SET_REA               PROCEDUR       295            
 METHODE   GET_IMA               PROCEDUR       296            
 METHODE   GET_REA               PROCEDUR       297            
********************* end of listing **************************

COM%SET_REA 2.5;
UU=COM%GET_REA; MESS ' real value ' uu; 

******************** start of  listing ************************
     real value   2.5000
********************* end of listing **************************

COM%SET_IMA 3.5; 
list com;
******************** start of listing *************************
      Objet de type OBJET de pointeur 25089
              Indice                          Objet
           Type    Valeur                  Type   Valeur
      MOT       CLASSE                MOT       COMPLEX             
      METHODE   METHODE               MOT       METHODE             
      METHODE   HERITE                MOT       HERI                
      METHODE   OUBLIER               MOT       ANNU                
      MOT       REA                   FLOTTANT    .25000000E+01     
      MOT       IMA                   FLOTTANT    .35000000E+01                
      METHODE   GET_IMA               PROCEDUR       296            
      METHODE   GET_REA               PROCEDUR       297            
      METHODE   MODULE                PROCEDUR       298        
********************* end of listing **************************

ZZ = COM%MODULE ; list ZZ; 

******************** start of  listing ************************
     Réel valant: 4.3012
********************* end of listing **************************

*
* set a new method MULTIplication
*
DEBMETH MULT RR;
'SI' (( 'EGA' ('TYPE'  RR ) 'ENTIER  ')   'OU'
      ( 'EGA' ('TYPE'  RR ) 'FLOTTANT'));
   %REA=%REA*RR;  %IMA=%IMA*RR;
'SINON';
   'SI'  ( 'EGA' ('TYPE'  RR ) 'OBJET   ') ;
      RE = %REA*(RR%GET_REA) -( %IMA * (RR%GET_IMA));
      IM = %REA*(RR%GET_IMA) +(%IMA *(RR%GET_REA));
      %REA=RE; %IMA=IM;
   'SINON';
      MESS ' Multiplication impossible';
      ERREUR 19;
   'FINSI';
'FINSI';
FINMETH;
*
*  add the new method to the object COM 
*
COM%METHODE MULTI MULT;
list com;

******************** start of  listing ************************
     Objet de type OBJET de pointeur 25089
              Indice                          Objet
           Type    Valeur                  Type   Valeur
      MOT       CLASSE                MOT       COMPLEX             
      METHODE   METHODE               MOT       METHODE             
      METHODE   HERITE                MOT       HERI                
      METHODE   OUBLIER               MOT       ANNU                
      MOT       REA                   FLOTTANT    .25000000E+01     
      MOT       IMA                   FLOTTANT    .35000000E+01              
      METHODE   GET_IMA               PROCEDUR       296            
      METHODE   GET_REA               PROCEDUR       297            
      METHODE   MODULE                PROCEDUR       298            
      METHODE   MULTI                 PROCEDUR       299
********************* end of listing **************************          

COM%MULTI 3.5;
list com;

******************** start of  listing ************************
    Objet de type OBJET de pointeur 25089
             Indice                          Objet
           Type    Valeur                  Type   Valeur
      MOT       CLASSE                MOT       COMPLEX             
      METHODE   METHODE               MOT       METHODE             
      METHODE   HERITE                MOT       HERI                
      METHODE   OUBLIER               MOT       ANNU                
      MOT       REA                   FLOTTANT    .87500000E+01     
      MOT       IMA                   FLOTTANT    .12250000E+02              
      METHODE   GET_IMA               PROCEDUR       296            
      METHODE   GET_REA               PROCEDUR       297            
      METHODE   MODULE                PROCEDUR       298            
      METHODE   MULTI                 PROCEDUR       299            
********************* end of listing **************************

aa = OBJET complex;
aa%set_ima 2;
aa%set_rea 2;
com%multi aa;
list com;

******************** start of  listing ************************ 
      Objet de type OBJET de pointeur 25089
              Indice                          Objet
           Type    Valeur                  Type   Valeur
      MOT       CLASSE                MOT       COMPLEX             
      METHODE   METHODE               MOT       METHODE             
      METHODE   HERITE                MOT       HERI                
      METHODE   OUBLIER               MOT       ANNU                
      MOT       REA                   FLOTTANT   -.70000000E+01     
      MOT       IMA                   FLOTTANT    .42000000E+02              
      METHODE   GET_IMA               PROCEDUR       296            
      METHODE   GET_REA               PROCEDUR       297            
      METHODE   MODULE                PROCEDUR       298            
      METHODE   MULTI                 PROCEDUR       299            
********************* end of listing **************************

yy = com%GET_REA; xx = COM%GET_IMA;

* aa  will get the MULTI method  by
* inherits between objects 

aa%HERITE COM;
list aa;

******************** start of  listing ************************ 
      Objet de type OBJET de pointeur 25259 
              Indice                          Objet
           Type    Valeur                  Type   Valeur
      MOT       CLASSE                MOT       COMPLEX            
      METHODE   METHODE               MOT       METHODE            
      METHODE   HERITE                MOT       HERI                
      METHODE   OUBLIER               MOT       ANNU               
      MOT       REA                   FLOTTANT    .20000000E+01     
      MOT       IMA                   FLOTTANT    .20000000E+01          
      METHODE   GET_IMA               PROCEDUR       296            
      METHODE   GET_REA               PROCEDUR       297            
      METHODE   MODULE                PROCEDUR       298            
      METHODE   MULTI                 PROCEDUR       299            
********************* end of listing **************************

'SI' (( ABS( YY + 7.00))  > 1.e-5); ERREUR 5;FINSI;
'SI'  (( ABS( XX - 42.0))  > 1.e-5) ; erreur 5; finsi;
FIN;

\end{verbatim}
\vspace{5mm}

A l'intérieur d'une méthode on applique une autre méthode sur l'objet par :

\vspace{5mm}
\% METH1   ARG1 ARG2 ..   
\vspace{5mm}

où METH1 est le nom de la méthode tandis qu'à
l'extérieur d'une méthode l'utilisateur peut appliquer une méthode sur un objet
par :

\vspace{5mm}
NOMOBJ\%METH1 ARG1 ARG2 ..
\vspace{5mm}

L'emploi des méthodes est encore à découvrir, elles permettent s\^urement un
contr\^ole syntaxique beaucoup plus précis que les procédures. La réécriture de
certaines procédures de Castem2000 en METHODES et OBJET est envisagée.

\chapter{Bibliographie}

\begin{itemize}
\item $[1]$ P.VERPEAUX, T.CHARRAS, A.MILLARD : 
"Castem2000 : une approche moderne du calcul des structures" 
Calcul des Structures et Intelligences artificielle, p261.
Pluralis 1988
\vspace{5mm}    

\item $[2]$ Th.CHARRAS, JJ.LAUTARD, MF.ROBEAU, P.VERPEAUX
"Langage GIBIANE : Définition"
Rapport DEMT/SERMA/89-
\vspace{5mm}    


\item  $[3]$ Th.CHARRAS :
"Castem2000 Gibiane"
Rapport DMT 94/154
\vspace{5mm}    

  \item $[4]$ Th.CHARRAS : 
"Développer dans Castem2000 : LES OBJETS"
Rapport  DMT/96-171
\vspace{5mm}     

\item  $[5]$ Th.CHARRAS : 
"Développer dans Castem2000 : ESOPE"
Rapport  DMT/96-172
\vspace{5mm}     

\item  $[6]$ Th.CHARRAS :
"Développer dans Castem2000 : LES OPERATEURS"
Rapport  DMT/96-173
\vspace{5mm}    

\item   $[7]$ A.CONSTANTINESCU, M.DRAGON, J.KICHENIN : 
"Programming Engineering Applications Using the Object Oriented FEM
code Castem2000." 
A para\^\i tre SIAM Workshop on Object Oriented Methods for
Interoperable Scientific and Engineering Computing 1998 Yorktown
Heights, New York 
\end{itemize}
 
\end{document}


 
