Exemples de jeux de données Cast3M

* fichier :  orieelem.dgibi
************************************************************************
* NOM         : ORIEELEM
* DESCRIPTION : On teste ORIE et INVE pour les elements massifs
*               sur des maillages à 1 element.
*               Egalement, on peut tracer les elements pour savoir
*               comment ils sont numerotes !
*
* Mots-cles : element de reference, numerotation, orientation, inversion
* Mots-clés : élément de référence, numérotation
*
*
* LANGAGE     : GIBIANE-CAST3M
* AUTEUR      : Stéphane GOUNAND (CEA/DEN/DM2S/SFME/LTMF)
*               mél : stephane.gounand@cea.fr
**********************************************************************
* VERSION    : v1, 09/05/2016, version initiale
* HISTORIQUE : v1, 09/05/2016, création
* HISTORIQUE :
* HISTORIQUE :
************************************************************************
'OPTI' 'ECHO' 0 ;
'SAUT' 'PAGE' ;
graph = faux ;
interact = faux ;
*
*'OPTI' debu 1 ;
*
* verifie que deux elements sont parfaitement identiques :
* noeuds decrits dans le meme ordre
'DEBPROC' egael ;
'ARGUMENT' el1*'MAILLAGE' ;
'ARGUMENT' el2*'MAILLAGE' ;
* Operateur ou directive ? Si directive, on signale les erreurs
* Sinon on renvoie la valeur du test.
'ARGUMENT' loper/'LOGIQUE' ;
'SI' ('NON' ('EXISTE' loper)) ;
   loper=vrai ;
'FINSI' ;
lok = vrai ;
* 1 seul
nbl1 = 'NBEL' el1 ;
nbl2 = 'NBEL' el2 ;
err = 'OU' ('NEG' nbl1 1) ('NEG' nbl2 1) ;
lok = lok 'ET' ('NON' err) ;
'SI' ('ET' err ('NON' loper)) ;
   'ERREUR' 'Un seul element pour les entrees' ;
'FINSI' ;   
* type
tel1 = 'EXTRAIRE' ('ELEM' el1 'TYPE') 1 ;
tel2 = 'EXTRAIRE' ('ELEM' el2 'TYPE') 1 ;
err = 'NEG' tel1 tel2 ;
lok = lok 'ET' ('NON' err) ;
'SI' ('ET' err ('NON' loper)) ;
   'ERREUR' 'Type differents' ;
'FINSI' ;   
nno1 = 'NBNO' el1 ;
nno2 = 'NBNO' el2 ;
err = 'NEG' nno1 nno2 ;
lok = lok 'ET' ('NON' err) ;
'SI' ('ET' err ('NON' loper)) ;
   'ERREUR' 'Pas le meme nbno pour les entrees' ;
'FINSI' ;   
* Boucle
* Ici, on suppose que le CHAN POI1 conserve l'ordre des noeuds de
* chaque element. A un moment, on a pense qu'une syntaxe type :
* p1 = POIN el1 &ino 'ELEM' 'TRI3' 1 ;
* serait plus claire.
*
pel1 = 'CHANGER' 'POI1' el1 ;
pel2 = 'CHANGER' 'POI1' el2 ;
'REPETER' ino nno1 ;
   p1 = 'POIN' pel1 &ino ;
   p2 = 'POIN' pel2 &ino ;
   err = 'NEG' p1 p2 ;
   lok = lok 'ET' ('NON' err) ;
   'SI' ('ET' err ('NON' loper)) ;
      'ERREUR' 'Pas les memes numeros de noeuds pour les entrees' ;
   'FINSI' ;   
'FIN' ino ;
'SI' loper ;
   'RESPRO' lok ;
'FINSI' ;
'FINPROC' ;
*
*
*
'DEBPROC' veri ;
'ARGUMENT' el*'MAILLAGE' ;
   nomel = 'EXTRAIRE' ('ELEM' el 'TYPE') 1 ;
   'MESSAGE' nomel ;
* On vérifie que :
* 1) inve() .ne. Id
* 2) inve(inve()) = Id
* 3) orie(inve())=Id 
* 4) orie()=Id car les elements sont orientes positivement de base
   ivel   = 'INVERSE' el ;
   ivivel = 'INVERSE' ivel ;
   'MESSAGE' 'NON EGAEL el ivel ;' ;
   tst = EGAEL el ivel ;
   'SI' tst ;
      'ERREUR' 'lelement et son inverse sont identiques' ;
   'FINSI' ;      
   'MESSAGE' 'EGAEL el ivivel ;' ;
   EGAEL el ivivel faux ;
   'MESSAGE' 'EGAEL el orivel ;' ;
   orivel = 'ORIENTER' ivel ;
   EGAEL el orivel faux ;
   'MESSAGE' 'EGAEL el orel ;' ;
   orel   = 'ORIENTER' el ;
   EGAEL el orel faux ;
   'SI' graph ;
      'LISTE' el ; 'TRACER' el 'NOEU' 'TITR' nomel ;
      'LISTE' ivel ; 'TRACER' ivel 'NOEU' 'TITR'
         ('CHAINE' 'INVE ' nomel) ;
   'FINSI' ;
*
'FINPROC' ;
*
*
*
'DEBPROC' veri2 ;
'ARGUMENT' el*'MAILLAGE' ;
'ARGUMENT' eli*'MAILLAGE' ;
   'OPTI' echo -1 ;
   'ELIMINATION' ('ET' el eli) 1.D-6 ;
   'OPTI' echo 1 ;
   nomel = 'EXTRAIRE' ('ELEM' el 'TYPE') 1 ;
   'MESSAGE' nomel ;
* On vérifie que :
* 1) inve(el) .eq. eli
   ivel   = 'INVERSE' el ;
   'MESSAGE' 'EGAEL ivel eli ;' ;
   EGAEL ivel eli faux ;
'FINPROC' ;
 
*
* Fin des procedures
*
*
'REPETER' idim 3 ;
   dim = &idim  ;
*dim = 3 ;
'SI' ('EGA' dim 1) ;
   'OPTI' 'DIME' 1 'ELEM' 'SEG2' ;
*
   p1 = 'POIN' 0. ; p2 = 'POIN' 1. ;
*   p3 = 'POIN' 0.5 ;
   se2 = 'MANU' 'SEG2' p1 p2 ;  VERI se2 ;
   se3 = 'CHANGER' se2 'QUAD' ; VERI se3 ;
* On construit un inverse à la main...
* Cela sert surtout pour les QUAFs 3D où on veut vérifier que l'on ne
* s'est pas trompé sur les noeuds faces et centre dans la programmation
* de inver4.eso
   se2i = 'MANU' 'SEG2' p2 p1 ;   VERI2 se2 se2i ;
   se3i = 'CHANGER' se2i 'QUAD' ; VERI2 se3 se3i ;
'FINSI' ;
'SI' ('EGA' dim 2) ;
   'OPTI' 'DIME' 2 'ELEM' 'TRI3' ;
   p1 = 0. 0. ; p2 = 1. 0. ; p3 = 1. 1. ; p4 = 0. 1. ;
   tr3 = 'MANU' 'TRI3' p1 p2 p3 ;     VERI tr3 ;
   tr6 = 'CHANGER' tr3 'QUAD' ;       VERI tr6 ;
   tr7 = 'CHANGER' tr6 'QUAF' ;       VERI tr7 ;
   qu4 = 'MANU' 'QUA4' p1 p2 p3 p4 ;  VERI qu4 ;
   qu8 = 'CHANGER' qu4 'QUAD' ;       VERI qu8 ;
   qu9 = 'CHANGER' qu8 'QUAF' ;       VERI qu9 ;
*
* Les inverses
*
   tr3i = 'MANU' 'TRI3' p1 p3 p2 ;     VERI2 tr3 tr3i ;
   tr6i = 'CHANGER' tr3i 'QUAD' ;      VERI2 tr6 tr6i ;
   tr7i = 'CHANGER' tr6i 'QUAF' ;      VERI2 tr7 tr7i ;
   qu4i = 'MANU' 'QUA4' p1 p4 p3 p2 ;  VERI2 qu4 qu4i ;
   qu8i = 'CHANGER' qu4i 'QUAD' ;      VERI2 qu8 qu8i ;
   qu9i = 'CHANGER' qu8i 'QUAF' ;      VERI2 qu9 qu9i ;
 
'FINSI' ;
'SI' ('EGA' dim 3) ;
   'OPTI' 'DIME' 3 'ELEM' 'TET4' ;
   p1 = 0. 0. 0. ; p2 = 1. 0. 0. ; p3 = 1. 1. 0. ; p4 = 0. 1. 0. ;
   p5 = 0. 0. 1. ; p6 = 1. 0. 1. ; p7 = 1. 1. 1. ; p8 = 0. 1. 1. ;
   te4 = 'MANU' 'TET4' p1 p2 p3 p5 ;             VERI te4 ;
   te10 = 'CHANGER' te4 'QUAD' ;                 VERI te10  ;
   te15 = 'CHANGER' te10 'QUAF' ;                VERI te15 ;
   py5 = 'MANU' 'PYR5' p1 p2 p3 p4 p5 ;          VERI py5 ;
   py13 = 'CHANGER' py5 'QUAD' ;                 VERI py13 ;
   py19 = 'CHANGER' py13 'QUAF' ;                VERI py19 ;
   pr6 = 'MANU' 'PRI6' p1 p2 p3 p5 p6 p7 ;       VERI pr6 ;
   pr15 = 'CHANGER' pr6 'QUAD' ;                 VERI pr15 ;
   pr21 = 'CHANGER' pr15 'QUAF' ;                VERI pr21 ;
   cu8 = 'MANU' 'CUB8' p1 p2 p3 p4 p5 p6 p7 p8 ; VERI cu8 ;
   cu20 = 'CHANGER' cu8 'QUAD' ;                 VERI cu20 ;
   cu27 = 'CHANGER' cu20 'QUAF' ;                VERI cu27 ;
*
* Les inverses
*
   te4i = 'MANU' 'TET4' p1 p3 p2 p5 ;             VERI2 te4 te4i ;
   te10i = 'CHANGER' te4i 'QUAD' ;                VERI2 te10 te10i ;
   te15i = 'CHANGER' te10i 'QUAF' ;               VERI2 te15 te15i ;
   py5i = 'MANU' 'PYR5' p1 p4 p3 p2 p5 ;          VERI2 py5 py5i ;
   py13i = 'CHANGER' py5i 'QUAD' ;                VERI2 py13 py13i ;
   py19i = 'CHANGER' py13i 'QUAF' ;               VERI2 py19 py19i ;
   pr6i = 'MANU' 'PRI6' p1 p3 p2 p5 p7 p6 ;       VERI2 pr6 pr6i ;
   pr15i = 'CHANGER' pr6i 'QUAD' ;                VERI2 pr15 pr15i ;
   pr21i = 'CHANGER' pr15i 'QUAF' ;               VERI2 pr21 pr21i ;
   cu8i = 'MANU' 'CUB8' p1 p4 p3 p2 p5 p8 p7 p6 ; VERI2 cu8 cu8i ;
   cu20i = 'CHANGER' cu8i 'QUAD' ;                VERI2 cu20 cu20i ;
   cu27i = 'CHANGER' cu20i 'QUAF' ;               VERI2 cu27 cu27i ;
* Test orientation decoupage tetra en cube
* Ce test provoquait une erreur incorrecte
* *****  ERREUR 318 ***** dans l'operateur ORIE
* Deux elements adjacents ont des orientations opposees
* avant les modifs de la fiche 8985.
   c1 = 'CHANGER' 'TET4' te15 ;
   c2 = 'CHANGER' 'QUAF' c1 ;
   c3 = 'CHANGER' 'CUB8' c2 ;
   tt = 'ORIENTER' c3 ;
'FINSI' ;
 
 
'FIN' idim ;
 
 
'SI' interact ;
   'OPTION' 'DONN' 5 'ECHO' 1 ;
'FINSI' ;   
 
*
* End of dgibi file ORIEELEM
*
'FIN' ;