Télécharger operquaf.dgibi

Retour à la liste

************************************************************************
* NOM         : OPERQUAF
* DESCRIPTION : Tester le fonctionnement de certains operateurs de
*               maillage avec les QUAFs suite aux modifications pour
*               gerer correctement les faces TRI7/QUA9.
*               Operateurs testes :
*               ENVELOPPE
*               CHANGER 'LIGN'
*               CHANGER 'FACE'
*               CHANGER 'QUAD'
*               MESURE
*               CONTOUR
*               VERSENS
*               VERM
*               Pour le test des traces compares entre les QUAF et les
*               autres elements, voir tracquaf.dgibi
*               Inspire de orieelem.dgibi
*
*
*
* LANGAGE     : GIBIANE-CAST3M
* AUTEUR      : Stéphane GOUNAND (CEA/DEN/DM2S/SFME/LTMF)
*               mél : stephane.gounand@cea.fr
**********************************************************************
* VERSION    : v1, 05/07/2016, version initiale
* HISTORIQUE : v1, 05/07/2016, création
* HISTORIQUE :
* HISTORIQUE :
************************************************************************
*
*
interact= FAUX ;
'OPTION' 'DIME' 3 'ELEM' CUB8  ;
'SI' ('NON' interact) ;
  'OPTION' 'TRAC' 'PS' ;
'SINON' ;
  'OPTION' 'TRAC' 'X' ;
'FINSI' ;
*
* verifie que deux maillages sont identiques au sens de DIFF
* cad en etant tolerant
* 
'DEBPROC' egamail2 ;
'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 ;
err = '>' ('NBEL' ('DIFF' el1 el2)) 0 ;
lok = lok 'ET' ('NON' err) ;
'SI' err ;
   'SI' ('NON' loper) ;
      'ERREUR' 'maillages differents en entree' ;
   'SINON' ;
      'RESPRO' lok ;
   'FINSI' ;      
'FINSI' ;
'FINPROC' ;
 
 
* verifie que deux maillages sont parfaitement identiques :
* elements et noeuds decrits dans le meme ordre
* utilise egael
'DEBPROC' egamail ;
'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 ;
nbl1 = 'NBEL' el1 ;
nbl2 = 'NBEL' el2 ;
err = ('NEG' nbl1 nbl2) ;
lok = lok 'ET' ('NON' err) ;
'SI' err ;
   'SI' ('NON' loper) ;
      'ERREUR' 'NB element different pour les entrees' ;
   'SINON' ;
      'RESPRO' lok ;
      'QUITTER' EGAMAIL ;
   'FINSI' ;      
'FINSI' ;
'SI' ('EGA' nbl1 0) ;
   'SI' loper ;
      'RESPRO' lok ;
      'QUITTER' EGAMAIL ;
   'FINSI' ;      
'FINSI' ;
tel1 = 'ELEM' el1 'TYPE' ;
tel2 = 'ELEM' el2 'TYPE' ;
err = 'NON' ('ET' ('EXISTE' tel1 tel2 'ET')
                  ('EXISTE' tel2 tel1 'ET')) ;
lok = lok 'ET' ('NON' err) ;
'SI' err ;
   'SI' ('NON' loper) ;
      'ERREUR' 'Type element different pour les entrees' ;
   'SINON' ;
      'RESPRO' lok ;
      'QUITTER' EGAMAIL ;
   'FINSI' ;      
'FINSI' ;
'REPETER' itel ('DIME' tel1) ;
   ty = 'EXTRAIRE' tel1 &itel ;
   sel1 = 'ELEM' el1 ty ;
   sel2 = 'ELEM' el2 ty ;
   nbl1 = 'NBEL' sel1 ;
   nbl2 = 'NBEL' sel2 ;
   err = ('NEG' nbl1 nbl2) ;
   lok = lok 'ET' ('NON' err) ;
   'SI' err ;
      'SI' ('NON' loper) ;
         cherr = 'CHAINE' 'NB element ' ty
                    ' different pour les entrees' ;
         'ERREUR' cherr ;
      'SINON' ;
         'RESPRO' lok ;
         'QUITTER' EGAMAIL ;
      'FINSI' ;      
   'FINSI' ;
   'REPETER' iel nbl1 ;
      esel1 = 'ELEM' sel1 &iel ;
      esel2 = 'ELEM' sel2 &iel ;
      lok = lok 'ET' (egael esel1 esel2) ;
      'SI' ('ET' ('NON' lok) ('NON' loper)) ;
         'ERREUR' 'Pas les memes numeros de noeuds pour les entrees' ;
      'FINSI' ;   
   'FIN' iel ;
'FIN' itel ;   
'SI' loper ;
   'RESPRO' lok ;
'FINSI' ;
'FINPROC' ;
 
* 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' vchlig ;
'ARGUMENT' el1*'MAILLAGE' ;
'ARGUMENT' el2*'MAILLAGE' ;
   nomel1 = 'EXTRAIRE' ('ELEM' el1 'TYPE') 1 ;
   nomel2 = 'EXTRAIRE' ('ELEM' el2 'TYPE') 1 ;
   'MESSAGE' 'CHAN LIGN ' nomel1 ' ' nomel2 ;
   l1 = 'CHANGER' 'LIGN' el1 ;
   l2 = 'CHANGER' 'LIGN' el2 ;
   EGAMAIL l1 l2 faux ;
*
'FINPROC' ;
 
'DEBPROC' vcont ;
'ARGUMENT' el1*'MAILLAGE' ;
'ARGUMENT' el2*'MAILLAGE' ;
   nomel1 = 'EXTRAIRE' ('ELEM' el1 'TYPE') 1 ;
   nomel2 = 'EXTRAIRE' ('ELEM' el2 'TYPE') 1 ;
   'MESSAGE' 'CONT ' nomel1 ' ' nomel2 ;
   l1 = 'CONTOUR' el1 ;
   l2 = 'CONTOUR' el2 ;
   EGAMAIL l1 l2 faux ;
*
'FINPROC' ;
 
'DEBPROC' vchqua ;
'ARGUMENT' el1*'MAILLAGE' ;
'ARGUMENT' el2*'MAILLAGE' ;
   nomel1 = 'EXTRAIRE' ('ELEM' el1 'TYPE') 1 ;
   nomel2 = 'EXTRAIRE' ('ELEM' el2 'TYPE') 1 ;
   'MESSAGE' ' ' nomel1 ' =? CHANGER QUAD '  nomel2 ;
   el2q = 'CHANGER' 'QUAD' el2 ;
   EGAMAIL el1 el2q faux ;
*
'FINPROC' ;
 
'DEBPROC' vchsur ;
'ARGUMENT' el1*'MAILLAGE' ;
*'ARGUMENT' el2*'MAILLAGE' ;
   nomel1 = 'EXTRAIRE' ('ELEM' el1 'TYPE') 1 ;
   'MESSAGE' 'CHAN SURF ' nomel1  ;
   ltyp = 'MOTS' 'TRI7' 'QUA9' ;
   fel1 = 'CHANGER' 'SURF' el1 ;
   tfel1 = 'ELEM' fel1 'TYPE' ;
   err = 'NON' ('EXISTE' ltyp tfel1 'ET') ;
   'SI' err ;
      'LISTE' tfel1 ;
      'ERREUR' 'Type element incorrect' ;
   'FINSI' ;
   'SI' ('EGA' ('NBEL' el1) 1) ;
      'MESSAGE' '  CHAN SURF =?  ENVE ' nomel1  ;
      evel1 = 'ENVELOPPE' el1 ;
      EGAMAIL fel1 evel1 faux ;
   'FINSI' ;      
   'MESSAGE' ' CHANLIGN(CHANSURF) ' nomel1 ' =? CHANLIGN' ;
   clel1 = 'CHANGER' 'LIGNE' el1 ;
   clfl1 = 'CHANGER' 'LIGNE' fel1 ;
   EGAMAIL2 clel1 clfl1 faux ;
*
'FINPROC' ;
 
'DEBPROC' venve ;
'ARGUMENT' el1*'MAILLAGE' ;
'ARGUMENT' el2*'MAILLAGE' ;
'ARGUMENT' el3*'MAILLAGE' ;
   nomel1 = 'EXTRAIRE' ('ELEM' el1 'TYPE') 1 ;
   nomel2 = 'EXTRAIRE' ('ELEM' el2 'TYPE') 1 ;
   nomel3 = 'EXTRAIRE' ('ELEM' el3 'TYPE') 1 ;
   'MESSAGE' 'ENVE ' nomel1 ' ' nomel2 ' ' nomel3 ;
   e1 = 'ENVELOPPE' el1 ;
   e2 = 'ENVELOPPE' el2 ;
*   'OPTI' impi 1 ;
   e3 = 'ENVELOPPE' el3 ;
*   'OPTI' impi 0 ;
   e1q = 'CHANGER' 'QUAF' e1 ;
   e2q = 'CHANGER' 'QUAF' e2 ;
   'ELIMINATION' (e1q 'ET' e2q 'ET' e3) 1.D-6 ;
   'MESSAGE' 'ENVE ' nomel1 ' ' nomel3 ;
* On est tolerant ici car l'ordre des elements depend des numeros de noeuds   
   EGAMAIL2 e1q e3 faux ;
   'MESSAGE' 'ENVE ' nomel2 ' ' nomel3 ;
   EGAMAIL2 e2q e3 faux ;
* Le nouveau enveloppe ! On recalcule l'ancien car les numéros de noeuds
* peuvent avoir changé à cause de ELIM  ce qui change la clé de hachage
* et l'ordre des faces
*   e1 = 'ENVELOPPE' el1 'OLD' ;
*   e2 = 'ENVELOPPE' el2 'OLD' ;
*   e1v = 'ENVELOPPE' el1  ;
*   e2v = 'ENVELOPPE' el2  ;
*   'MESSAGE' 'ENVE ' nomel1 ' ANCIEN-NOUVEAU' ;
*   EGAMAIL e1v e1 faux ;
*   'MESSAGE' 'ENVE ' nomel2 ' ANCIEN-NOUVEAU' ;
*   EGAMAIL e2v e2 faux ;
*
'FINPROC' ;
 
'DEBPROC' vvers ;
'ARGUMENT' el1*'MAILLAGE' ;
'ARGUMENT' el2*'MAILLAGE' ;
   nomel1 = 'EXTRAIRE' ('ELEM' el1 'TYPE') 1 ;
   nomel2 = 'EXTRAIRE' ('ELEM' el2 'TYPE') 1 ;
   'MESSAGE' 'VERS ' nomel1 ' ' nomel2 ;
   l1 = 'VERSENS' el1 ;
   l2 = 'VERSENS' el2 ;
   l1q = 'CHANGER' 'QUAF' l1 ;
   'ELIMINATION' ('ET' l1q l2) 1.D-6 ;
   EGAMAIL l1q l2 faux ;
*
'FINPROC' ;
 
'DEBPROC' vverm ;
'ARGUMENT' el1*'MAILLAGE' ;
'ARGUMENT' el2*'MAILLAGE' ;
   nomel1 = 'EXTRAIRE' ('ELEM' el1 'TYPE') 1 ;
   nomel2 = 'EXTRAIRE' ('ELEM' el2 'TYPE') 1 ;
   'MESSAGE' 'VERM ' nomel1 ' ' nomel2 ;
   'VERM' el1 ;
   'VERM' el2 ;
*
'FINPROC' ;
 
 
'DEBPROC' vmesu ;
'ARGUMENT' el1*'MAILLAGE' ;
'ARGUMENT' el2*'MAILLAGE' ;
'ARGUMENT' el3*'MAILLAGE' ;
   nomel1 = 'EXTRAIRE' ('ELEM' el1 'TYPE') 1 ;
   nomel2 = 'EXTRAIRE' ('ELEM' el2 'TYPE') 1 ;
   nomel3 = 'EXTRAIRE' ('ELEM' el3 'TYPE') 1 ;
   'MESSAGE' 'MESU ' nomel1 ' ' nomel2 ' ' nomel3 ;
*   'OPTI' impi 1 ;
   v1 = 'MESURE' el1 ;
   v2 = 'MESURE' el2 ;
   v3 = 'MESURE' el3 ;
*   'OPTI' impi 0 ;
   lq2='MOTS' 'TRI6' 'QUA8' ;
   lq3='MOTS' 'CU20' 'PY13' 'PR15' 'TE10' ;
   lq23 = lq2 'ET' lq3 ;
   'SI' ('NON' ('EXISTE' lq23 nomel2)) ;
      cherr = 'CHAINE' 'element ' nomel1 ' pas prevu' ;
      'ERREUR' cherr ;
   'FINSI' ;
   'SI' ('EXISTE' lq2 nomel2) ;
      cel1 = 'CONTOUR' el1 ; cel2 = 'CONTOUR' el2 ;
      cel3 = 'CONTOUR' el3 ;
      v4 = 'MESURE' cel1 'SURF' ;  v5 = 'MESURE' cel2 'SURF' ;
      v6 = 'MESURE' cel3 'SURF' ;
   'FINSI' ;      
   'SI' ('EXISTE' lq3 nomel2) ;
      cel1 = 'ENVELOPPE' el1 ; cel2 = 'ENVELOPPE' el2 ;
      cel3 = 'ENVELOPPE' el3 ;
      v4 = 'MESURE' cel1 'VOLU' ;  v5 = 'MESURE' cel2 'VOLU' ;
      v6 = 'MESURE' cel3 'VOLU' ;
   'FINSI' ;      
   lv = 'PROG' v1 v2 v3 v4 v5 v6 ;
   'MESSAGE' 'Mesures :' ; 'LISTE' lv ;
   milv = 'MINIMUM' lv ; malv = 'MAXIMUM' lv ;
   'MESSAGE' 'min=' milv ' max=' malv  ' max-min=' ('-' malv milv) ;
   'SI' ('NEG' milv malv 1.d-12) ;
      'ERREUR' 'Les volumes devraient etre egaux' ;
   'FINSI' ;
*Tester egalement enveloppe 'ET' 'MESURE' VOLUME '+' un QUAF
* non regulier ???
*
'FINPROC' ;
*
'OPTI' debu 1 ;
*
'REPETER' idim 3 ;
   dim = &idim  ;
'SI' ('EGA' dim 1) ;
   'OPTI' 'DIME' 1 'ELEM' 'SEG2' ;
*
   p1 = 'POIN' 0. ; p2 = 'POIN' 1. ;
*   p3 = 'POIN' 0.5 ;
   se2 = 'MANU' 'SEG2' p1 p2 ;  
   se3 = 'CHANGER' se2 'QUAD' ; 
* 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 ; 
   se3i = 'CHANGER' se2i 'QUAD' ;
'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 ;    
   tr6 = 'CHANGER' tr3 'QUAD' ;      
   tr7 = 'CHANGER' tr6 'QUAF' ;      
*
   qu4 = 'MANU' 'QUA4' p1 p2 p3 p4 ; 
   qu8 = 'CHANGER' qu4 'QUAD' ;      
   qu9 = 'CHANGER' qu8 'QUAF' ;
*
* Les inverses
*
   tr3i = 'MANU' 'TRI3' p1 p3 p2 ;   
   tr6i = 'CHANGER' tr3i 'QUAD' ;    
   tr7i = 'CHANGER' tr6i 'QUAF' ;    
   qu4i = 'MANU' 'QUA4' p1 p4 p3 p2 ;
   qu8i = 'CHANGER' qu4i 'QUAD' ;    
   qu9i = 'CHANGER' qu8i 'QUAF' ;    
* Test de CHANGER LIGNE
   VCHLIG tr6 tr7 ; VCHLIG qu8 qu9 ;
   VCHLIG tr6i tr7i ; VCHLIG qu8i qu9i ;
* Test de ENVE
   VENVE tr3 tr6 tr7 ; VENVE qu4 qu8 qu9 ;
* Test de CONT
   VCONT tr6 tr7 ; VCONT qu8 qu9 ;
   VCONT tr6i tr7i ; VCONT qu8i qu9i ;
* Test de VERSENS
   VVERS tr6 tr7 ; VVERS qu8 qu9 ;
   VVERS tr6i tr7i ; VVERS qu8i qu9i ;
* Test de VERM
   VVERM tr6 tr7 ; VVERM qu8 qu9 ;
   VVERM tr6i tr7i ; VVERM qu8i qu9i ;
* Test de MESU on melange exprès les inverses pour le signe...
   VMESU tr3i tr6 tr7 ; VMESU qu4i qu8 qu9 ;
   VMESU tr3 tr6i tr7i ; VMESU qu4 qu8i qu9i ;
* Test de CHAN QUAD
   VCHQUA tr6 tr7 ; VCHQUA qu8 qu9 ;
   VCHQUA tr6i tr7i ; VCHQUA qu8i qu9i ;
* Test de CHAN SURF
   VCHSUR tr7 ; VCHSUR qu9 ;
   VCHSUR tr7i ; VCHSUR 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 ;            
   te10 = 'CHANGER' te4 'QUAD' ;                
   te15 = 'CHANGER' te10 'QUAF' ;               
   py5 = 'MANU' 'PYR5' p1 p2 p3 p4 p5 ;         
   py13 = 'CHANGER' py5 'QUAD' ;                
   py19 = 'CHANGER' py13 'QUAF' ;               
   pr6 = 'MANU' 'PRI6' p1 p2 p3 p5 p6 p7 ;      
   pr15 = 'CHANGER' pr6 'QUAD' ;                
   pr21 = 'CHANGER' pr15 'QUAF' ;               
   cu8 = 'MANU' 'CUB8' p1 p2 p3 p4 p5 p6 p7 p8 ;
   cu20 = 'CHANGER' cu8 'QUAD' ;                
   cu27 = 'CHANGER' cu20 'QUAF' ;               
*
* Les inverses
*
   te4i = 'MANU' 'TET4' p1 p3 p2 p5 ;           
   te10i = 'CHANGER' te4i 'QUAD' ;              
   te15i = 'CHANGER' te10i 'QUAF' ;             
   py5i = 'MANU' 'PYR5' p1 p4 p3 p2 p5 ;        
   py13i = 'CHANGER' py5i 'QUAD' ;              
   py19i = 'CHANGER' py13i 'QUAF' ;             
   pr6i = 'MANU' 'PRI6' p1 p3 p2 p5 p7 p6 ;     
   pr15i = 'CHANGER' pr6i 'QUAD' ;              
   pr21i = 'CHANGER' pr15i 'QUAF' ;             
   cu8i = 'MANU' 'CUB8' p1 p4 p3 p2 p5 p8 p7 p6  ;
   cu20i = 'CHANGER' cu8i 'QUAD' ;              
   cu27i = 'CHANGER' cu20i 'QUAF' ;             
* Test de CHANGER LIGNE
   VCHLIG te10 te15 ; VCHLIG py13 py19 ; VCHLIG pr15 pr21 ;
   VCHLIG cu20 cu27 ;
   VCHLIG te10i te15i ; VCHLIG py13i py19i ; VCHLIG pr15i pr21i ;
   VCHLIG cu20i cu27i ;
* Test de ENVE
   VENVE te4 te10 te15 ; VENVE py5 py13 py19 ; VENVE pr6 pr15 pr21 ;
   VENVE cu8 cu20 cu27 ;
   VENVE te4i te10i te15i ; VENVE py5i py13i py19i ;
   VENVE pr6i pr15i pr21i ;
   VENVE cu8i cu20i cu27i ;
* Test de VERSENS
   VVERS te10 te15 ; VVERS py13 py19 ; VVERS pr15 pr21 ;
   VVERS cu20 cu27 ;
   VVERS te10i te15i ; VVERS py13i py19i ; VVERS pr15i pr21i ;
   VVERS cu20i cu27i ;
* Test de VERM
   VVERM te10 te15 ; VVERM py13 py19 ; VVERM pr15 pr21 ;
   VVERM cu20 cu27 ;
   VVERM te10i te15i ; VVERM py13i py19i ; VVERM pr15i pr21i ;
   VVERM cu20i cu27i ;
* Test de MESU on melange exprès les inverses le signe doit etre positif...
   VMESU te4i te10 te15 ; VMESU py5i py13 py19 ; VMESU pr6i pr15 pr21 ;
   VMESU cu8i cu20 cu27 ;
   VMESU te4 te10i te15i ; VMESU py5 py13i py19i ;
   VMESU pr6 pr15i pr21i ;
   VMESU cu8 cu20i cu27i ;
* Test de CHAN QUAD
   VCHQUA te10 te15 ; VCHQUA py13 py19 ; VCHQUA pr15 pr21 ;
   VCHQUA cu20 cu27 ;
   VCHQUA te10i te15i ; VCHQUA py13i py19i ; VCHQUA pr15i pr21i ;
   VCHQUA cu20i cu27i ;
* Test de CHAN SURF
   VCHSUR te15 ; VCHSUR py19 ; VCHSUR pr21 ;
   VCHSUR cu27 ;
   VCHSUR te15i ; VCHSUR py19i ; VCHSUR pr21i ;
   VCHSUR 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 ;
   ttq  = 'CHANGER' 'QUAD' tt ;
   ttqf = 'CHANGER' 'QUAF' ttq ;
   VCHLIG ttq ttqf
   VENVE tt ttq ttqf ;
   VVERS ttq ttqf ;
   VVERM ttq ttqf ;
   VMESU ('INVERSE' tt) ttq ttqf ;
   VCHQUA ttq ttqf ;
   VCHSUR ttqf ;
'FINSI' ;
 
 
'FIN' idim ;
 
 
'SI' interact ;
   'OPTION' 'DONN' 5 'ECHO' 1 ;
'FINSI' ;   
*
* End of dgibi file OPERQUAF
*
'FIN' ;
 
 
 
 

© Cast3M 2003 - Tous droits réservés.
Mentions légales