1 /****************************************************************************
   2 * COPYRIGHT (C) 1999 - 2007  EDF R&D, CEA/DEN
   3 * THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
   4 * IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 
   5 * AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
   6 * EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
   7 *  
   8 * THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
   9 * WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
  10 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
  11 * LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
  12 *
  13 * YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
  14 * ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
  15 * INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
  16 *
  17 ******************************************************************************/
  18 
  19 /******************************************************************************
  20  * - Nom du fichier : mdump.c
  21  *
  22  * - Description : utilitaire de dump pour fichier MED
  23  *                 Ce fichier contient les fonctions suivantes
  24  *                 qui constituent des modeles de programmation
  25  *                 pour une lecture generique d'un fichier MED :
  26  *                 - lecture_maillage_non_structure () :
  27  *                        1. Noeuds.
  28  *                        2. Mailles.
  29  *                        3. Faces (connectivite descendante).
  30  *                        4. Aretes (connectivite descendante).
  31  *                        5. Familles.
  32  *                        6. Equivalences.
  33  *                        7. Joints.
  34  *                 - lecture_maillage_structure ()     : 
  35  *                        1. Noeuds.
  36  *                        2. Mailles.
  37  *                        3. Familles.
  38  *                        4. Equivalences.
  39  *                        5. Joints.
  40  *                 - lecture_resultats () :
  41  *                        1. Champs de resultats relatifs à un maillage.
  42  *                           - Entites :
  43  *                                - Noeuds
  44  *                                - Mailles
  45  *                                - Faces
  46  *                                - Aretes
  47  *                           - Gestion des pas de temps et numeros d'ordre :
  48  *                                  valeurs associees a un ou plusieurs maillages sous 
  49  *                                  un meme pas de temps.
  50  *                           - Gestion des profils.
  51  *                           - Gestion des liens vers des maillages distants
  52  *                           - Gestion des points de Gauss :
  53  *                                - localisation des points de Gauss.
  54  *                 - lecture_parametres_scalaires () : 
  55  *                           - Valeurs scalaires entieres ou flottantes.
  56  *                           - Gestion des pas de temps et numeros d'ordre.
  57  *                 - main() : infos generales + lecture de tous les champs et 
  58  *                            du fichier MED passe en parametre.
  59  *
  60  *****************************************************************************/
  61 
  62 #define MESGERR
  63 
  64 #ifdef __cplusplus
  65 extern "C" {
  66 #endif
  67 
  68 #include <med.h>
  69 #include <med_config.h>
  70 #include <med_utils.h>
  71 #include <med_misc.h>
  72 #include <stdio.h>
  73 #include <string.h>
  74 #include <stdlib.h>
  75 
  76 #ifdef __cplusplus
  77 }
  78 #endif
  79 
  80 #ifdef PPRO_NT
  81 #define F_OK 0
  82 #else
  83 #include <unistd.h>
  84 #endif
  85 
  86 /* indique si on ecrit seulement la structure */
  87 int structure = 0;
  88 
  89 /* types geometriques des mailles references dans le modele MED */
  90 med_geometrie_element typmai[MED_NBR_GEOMETRIE_MAILLE] = { MED_POINT1,
  91                                                            MED_SEG2,
  92                                                            MED_SEG3,
  93                                                            MED_TRIA3,
  94                                                            MED_TRIA6,
  95                                                            MED_QUAD4,
  96                                                            MED_QUAD8,
  97                                                            MED_TETRA4,
  98                                                            MED_TETRA10,
  99                                                            MED_HEXA8,
 100                                                            MED_HEXA20,
 101                                                            MED_PENTA6,
 102                                                            MED_PENTA15,
 103                                                            MED_PYRA5,
 104                                                            MED_PYRA13};
 105 char nommai[MED_NBR_GEOMETRIE_MAILLE] [MED_TAILLE_NOM+1] = {"MED_POINT1",
 106                                                             "MED_SEG2",
 107                                                             "MED_SEG3",
 108                                                             "MED_TRIA3",
 109                                                             "MED_TRIA6",
 110                                                             "MED_QUAD4",
 111                                                             "MED_QUAD8",
 112                                                             "MED_TETRA4",
 113                                                             "MED_TETRA10",
 114                                                             "MED_HEXA8",
 115                                                             "MED_HEXA20",
 116                                                             "MED_PENTA6",
 117                                                             "MED_PENTA15",
 118                                                             "MED_PYRA5",
 119                                                             "MED_PYRA13"};
 120 med_geometrie_element typfac[MED_NBR_GEOMETRIE_FACE] = {MED_TRIA3,
 121                                                         MED_TRIA6,
 122                                                         MED_QUAD4,
 123                                                         MED_QUAD8};
 124 char nomfac[MED_NBR_GEOMETRIE_FACE][MED_TAILLE_NOM+1] = {"MED_TRIA3",
 125                                                          "MED_TRIA6",
 126                                                          "MED_QUAD4",
 127                                                          "MED_QUAD8"};
 128 med_geometrie_element typare[MED_NBR_GEOMETRIE_ARETE] = {MED_SEG2,
 129                                                          MED_SEG3};
 130 char nomare[MED_NBR_GEOMETRIE_ARETE] [MED_TAILLE_NOM+1] = {"MED_SEG2",
 131                                                            "MED_SEG3"};
 132 
 133 #define USER_MODE MED_COMPACT
 134 
 135 med_int lecture_nombre_famille(med_idt fid,char *nommaa)
 136 {
 137   med_int nfam = MEDnFam(fid,nommaa);
 138   EXIT_IF(nfam < 0,"lors de la lecture du nombre de familles",NULL);
 139   fprintf(stdout,"- Nombre de familles : %d \n",nfam);
 140 
 141   return nfam;
 142 }
 143 
 144 void lecture_famille_maillage(med_idt fid,char *nommaa,med_int nfam)
 145 {
 146   med_int i,j;
 147   med_int natt,ngro;
 148   char *attdes,*gro;
 149   med_int *attval,*attide;
 150   char nomfam[MED_TAILLE_NOM+1];
 151   med_int numfam;
 152   char str1[MED_TAILLE_DESC+1];
 153   char str2[MED_TAILLE_LNOM+1];
 154   med_err ret = 0;
 155   int famille_0 = 0;
 156 
 157   fprintf(stdout,"\n(**************************)\n");
 158   fprintf(stdout,"(* FAMILLES DU MAILLAGE : *)\n");
 159   fprintf(stdout,"(**************************)\n");
 160 
 161   for (i=0;i<nfam;i++) {
 162 
 163     /* nombre de groupes */
 164     ngro = MEDnGroupe(fid,nommaa,i+1);
 165     EXIT_IF(ngro < 0,"lors de la lecture du nombre de groupe d'une famille",
 166             NULL);
 167 
 168     /* nombre d'attributs */
 169     natt = MEDnAttribut(fid,nommaa,i+1);
 170     EXIT_IF(natt < 0,"lors de la lecture du nombre d'attributs d'une famille",
 171             NULL);
 172 
 173     fprintf(stdout,"- Famille %d a %d attributs et %d groupes \n",i+1,natt,
 174             ngro);
 175 
 176     /* nom,numero,attributs,groupes */
 177 
 178     /* allocation memoire */
 179     attide = (med_int*) malloc(sizeof(med_int)*natt);
 180     EXIT_IF(attide == NULL,NULL,NULL);
 181     attval = (med_int*) malloc(sizeof(med_int)*natt);
 182     EXIT_IF(attval == NULL,NULL,NULL);
 183     attdes = (char *) malloc(MED_TAILLE_DESC*natt+1);
 184     EXIT_IF(attdes == NULL,NULL,NULL);
 185     gro = (char*) malloc(MED_TAILLE_LNOM*ngro+1);
 186     EXIT_IF(gro == NULL,NULL,NULL);
 187 
 188     ret = MEDfamInfo(fid,nommaa,i+1,nomfam,&numfam,attide,attval,
 189                      attdes,&natt,gro,&ngro);
 190     EXIT_IF(ret < 0,"lors de la lecture des informations d'une famille",
 191             NULL);
 192         if (numfam == 0)
 193           famille_0 = 1;
 194 
 195     if (!structure) {
 196     /* affichage des resultats */
 197     fprintf(stdout,"  - Famille de nom %s et de numero %d : \n",nomfam,numfam);
 198     fprintf(stdout,"  - Attributs : \n");
 199     for (j=0;j<natt;j++) {
 200       strncpy(str1,attdes+j*MED_TAILLE_DESC,MED_TAILLE_DESC);
 201       str1[MED_TAILLE_DESC] = '\0';
 202       fprintf(stdout,"   ide = %d - val = %d - des = %s\n",*(attide+j),
 203               *(attval+j),str1);
 204     }
 205     }
 206 
 207     /* on libere la memoire */
 208     free(attide);
 209     free(attval);
 210     free(attdes);
 211 
 212     if (!structure) {
 213     fprintf(stdout,"  - Groupes :\n");
 214     for (j=0;j<ngro;j++) {
 215       strncpy(str2,gro+j*MED_TAILLE_LNOM,MED_TAILLE_LNOM);
 216       str2[MED_TAILLE_LNOM] = '\0';
 217       fprintf(stdout,"   gro = %s\n",str2);
 218     }
 219     }
 220 
 221     /* on libere la memoire */
 222     free(gro);
 223   }
 224   EXIT_IF(famille_0 != 1,"Pas de famille de numéro 0",
 225             NULL);
 226 
 227   return;
 228 }
 229 
 230 med_int lecture_nombre_equivalence(med_idt fid,char *nommaa)
 231 {
 232   med_int nequ = MEDnEquiv(fid,nommaa);
 233   EXIT_IF(nequ < 0,"lors de la lecture du nombre d'equivalences",NULL);
 234   fprintf(stdout,"- Nombre d'equivalences : %d \n",nequ);
 235 
 236   return nequ;
 237 }
 238 
 239 /* nombre de mailles concernees par les equivalences */
 240 #define NBR_MAILLE_EQU  7
 241 void lecture_equivalence_maillage(med_idt fid,char *nommaa,med_int nequ)
 242 {
 243   med_int i,j,k;
 244   med_int ncor;
 245   med_int *cor;
 246   char equ[MED_TAILLE_NOM+1];
 247   char des[MED_TAILLE_DESC+1];
 248   med_int desmai[MED_NBR_GEOMETRIE_MAILLE] = {0,2,3,3,3,4,4,4,4,6,6,5,5,5,5};
 249   med_int nmailles[MED_NBR_GEOMETRIE_MAILLE];
 250   med_int desfac[MED_NBR_GEOMETRIE_FACE] = {3,3,4,4};
 251   med_int nfaces[MED_NBR_GEOMETRIE_FACE];
 252   med_int desare[MED_NBR_GEOMETRIE_ARETE] = {2,3};
 253   med_int naretes[MED_NBR_GEOMETRIE_ARETE];
 254   med_err ret = 0;
 255 
 256   fprintf(stdout,"\n(******************************)\n");
 257   fprintf(stdout,"(* EQUIVALENCES DU MAILLAGE : *)\n");
 258   fprintf(stdout,"(******************************)\n");
 259 
 260   if (nequ == 0)
 261     fprintf(stdout,"- Aucune équivalence \n");
 262 
 263   /* lecture de toutes les equivalences associes a nommaa */
 264   for (i = 0;i<nequ;i++) {
 265     fprintf(stdout,"- Equivalence numero : %d ",i+1);
 266 
 267     /* lecture des infos sur l'equivalence */
 268     ret = MEDequivInfo(fid,nommaa,i+1,equ,des);
 269     EXIT_IF(ret < 0,"lors de la lecture des informations sur une equivalence",
 270             NULL);
 271     fprintf(stdout,"\n  - Nom de l'equivalence: %s \n",equ);
 272     fprintf(stdout,"\n  - Description de l'equivalence : %s \n",des);
 273 
 274     /* lecture des correspondances sur les differents types d'entites */
 275 
 276     /* les noeuds */
 277     ncor = MEDnCorres(fid,nommaa,equ,MED_NOEUD,(med_geometrie_element)0);
 278     EXIT_IF(ncor < 0,
 279             "lors de la lecture du nombre de correspondances d'une equivalence",
 280             NULL);
 281     fprintf(stdout,"\n  - Il y a %d correspondances sur les noeuds \n",ncor);
 282 
 283     if (ncor > 0) {
 284 
 285       /* allocation memoire */
 286       cor = (med_int*) malloc(sizeof(med_int)*ncor*2);
 287       EXIT_IF(cor == NULL,NULL,NULL);
 288 
 289       ret = MEDequivLire(fid,nommaa,equ,cor,ncor,MED_NOEUD,(med_geometrie_element)0);
 290       EXIT_IF(ret < 0,"lors de la lecture du tableau des correspondances",
 291               NULL);
 292     if (!structure) {
 293       for (j=0;j<ncor;j++)
 294         fprintf(stdout,"\n  - Correspondance %d : %d et %d \n",j+1,*(cor+2*j),
 295                       *(cor+2*j+1));
 296     }
 297       free(cor);
 298     }
 299 
 300     /* sur les mailles : on ne prend pas en compte les mailles 3D */
 301     for (j=0;j<NBR_MAILLE_EQU;j++) {
 302 
 303       ncor = MEDnCorres(fid,nommaa,equ,MED_MAILLE,typmai[j]);
 304       EXIT_IF(ncor < 0,
 305               "lors de la lecture du nombre de correspondances dans une equivalence",
 306               NULL);
 307       fprintf(stdout,"\n  - Il y a %d correspondances sur les mailles %s \n",ncor,
 308               nommai[j]);
 309 
 310       if (ncor > 0) {
 311 
 312         /* allocation memoire */
 313         cor = (med_int*) malloc(sizeof(med_int)*ncor*2);
 314         EXIT_IF(cor == NULL,NULL,NULL);
 315 
 316         ret = MEDequivLire(fid,nommaa,equ,cor,ncor,MED_MAILLE,
 317                            typmai[j]);
 318         EXIT_IF(ret < 0,"lors de la lecture du tableau des equivalences",
 319                 NULL);
 320 
 321       if (!structure) {
 322         for (k=0;k<ncor;k++)
 323           fprintf(stdout,"\n  - Correspondance %d : %d et %d \n",k+1,
 324                   *(cor+2*k),*(cor+2*k+1));
 325       }
 326 
 327         free(cor);
 328       }
 329     }
 330 
 331     /* sur les mailles Polygonales */
 332 
 333       ncor = MEDnCorres(fid,nommaa,equ,MED_MAILLE,MED_POLYGONE);
 334       EXIT_IF(ncor < 0,
 335               "lors de la lecture du nombre de correspondances dans une equivalence",
 336               NULL);
 337       fprintf(stdout,"\n  - Il y a %d correspondances sur les mailles polygone \n",ncor);
 338 
 339       if (ncor > 0) {
 340 
 341         /* allocation memoire */
 342         cor = (med_int*) malloc(sizeof(med_int)*ncor*2);
 343         EXIT_IF(cor == NULL,NULL,NULL);
 344 
 345         ret = MEDequivLire(fid,nommaa,equ,cor,ncor,MED_MAILLE,
 346                            MED_POLYGONE);
 347         EXIT_IF(ret < 0,"lors de la lecture du tableau des equivalences",
 348                 NULL);
 349 
 350       if (!structure) {
 351         for (k=0;k<ncor;k++)
 352           fprintf(stdout,"\n  - Correspondance %d : %d et %d \n",k+1,
 353                   *(cor+2*k),*(cor+2*k+1));
 354       }
 355 
 356         free(cor);
 357       }
 358 
 359 
 360     /* sur les faces */
 361     for (j=0;j<MED_NBR_GEOMETRIE_FACE;j++) {
 362 
 363       ncor = MEDnCorres(fid,nommaa,equ,MED_FACE,typfac[j]);
 364       EXIT_IF(ncor < 0,
 365               "lors de la lecture du nombre de correspondances dans une equivalence",
 366               NULL);
 367       fprintf(stdout,"\n  - Il y a %d correspondances sur les faces %s\n",ncor,
 368               nomfac[j]);
 369 
 370       if (ncor > 0) {
 371 
 372         /* allocation memoire */
 373         cor = (med_int*) malloc(sizeof(med_int)*ncor*2);
 374         EXIT_IF(cor == NULL,NULL,NULL);
 375 
 376         ret = MEDequivLire(fid,nommaa,equ,cor,ncor,MED_FACE,
 377                            typfac[j]);
 378         EXIT_IF(ret < 0,"lors de la lecture du tableau des equivalences",
 379                 NULL);
 380 
 381       if (!structure) {
 382         for (k=0;k<ncor;k++)
 383           fprintf(stdout,"\n  - Correspondance %d : %d et %d \n",k+1,*(cor+2*k),
 384                           *(cor+2*k+1));
 385       }
 386 
 387         free(cor);
 388       }
 389     }
 390 
 391     /* sur les faces Polygonales */
 392 
 393       ncor = MEDnCorres(fid,nommaa,equ,MED_FACE,MED_POLYGONE);
 394       EXIT_IF(ncor < 0,
 395               "lors de la lecture du nombre de correspondances dans une equivalence",
 396               NULL);
 397       fprintf(stdout,"\n  - Il y a %d correspondances sur les faces polygone \n",ncor);
 398 
 399       if (ncor > 0) {
 400 
 401         /* allocation memoire */
 402         cor = (med_int*) malloc(sizeof(med_int)*ncor*2);
 403         EXIT_IF(cor == NULL,NULL,NULL);
 404 
 405         ret = MEDequivLire(fid,nommaa,equ,cor,ncor,MED_FACE,
 406                            MED_POLYGONE);
 407         EXIT_IF(ret < 0,"lors de la lecture du tableau des equivalences",
 408                 NULL);
 409 
 410       if (!structure) {
 411         for (k=0;k<ncor;k++)
 412           fprintf(stdout,"\n  - Correspondance %d : %d et %d \n",k+1,*(cor+2*k),
 413                           *(cor+2*k+1));
 414       }
 415 
 416         free(cor);
 417       }
 418 
 419     /*  sur les aretes */
 420     for (j=0;j<MED_NBR_GEOMETRIE_ARETE;j++) {
 421 
 422       ncor = MEDnCorres(fid,nommaa,equ,MED_ARETE,typare[j]);
 423       EXIT_IF(ncor < 0,"lors de la lecture du nombre de correspondances",
 424               NULL);
 425       fprintf(stdout,"\n  - Il y a %d correspondances sur les aretes %s \n",
 426               ncor,nomare[j]);
 427 
 428       if (ncor > 0) {
 429 
 430         /* allocation memoire */
 431         cor = (med_int*) malloc(sizeof(med_int)*ncor*2);
 432         EXIT_IF(cor == NULL,NULL,NULL);
 433 
 434         ret = MEDequivLire(fid,nommaa,equ,cor,ncor,MED_ARETE,
 435                            typare[j]);
 436         EXIT_IF(ret < 0,"lors de la lecture du tableau des equivalences",
 437                 NULL);
 438 
 439       if (!structure) {
 440         for (k=0;k<ncor;k++)
 441           fprintf(stdout,"\n  Correspondance %d : %d et %d \n",k+1,*(cor+2*k),
 442                         *(cor+2*k+1));
 443       }
 444 
 445         free(cor);
 446       }
 447     }
 448   }
 449 
 450   return;
 451 }
 452 
 453 
 454 med_int lecture_nombre_joint(med_idt fid,char *nommaa)
 455 {
 456   med_int njnt = MEDnJoint(fid,nommaa);
 457   EXIT_IF(njnt < 0,"lors de la lecture du nombre de joints",NULL);
 458   fprintf(stdout,"- Nombre de joints : %d \n",njnt);
 459 
 460   return njnt;
 461 }
 462 
 463 
 464 void lecture_joint_maillage(med_idt fid,char *nommaa,med_int njnt)
 465 {
 466   med_int i,k;
 467   char des[MED_TAILLE_DESC+1];
 468   med_int ndom,nent;
 469   med_int typ_ent_local,typ_geo_local,typ_ent_distant,typ_geo_distant;
 470   med_int geo_ent_local,geo_ent_distant;
 471 
 472   char jn[MED_TAILLE_NOM+1];
 473   char maa_dist[MED_TAILLE_NOM+1];
 474   char corr[MED_TAILLE_NOM+1];
 475   med_int *cortab;
 476 
 477   const med_int nb_geo_ent=1+NBR_MAILLE_EQU+1+MED_NBR_GEOMETRIE_ARETE+MED_NBR_GEOMETRIE_FACE+1;
 478   med_geometrie_element typ_geo_ent[1+NBR_MAILLE_EQU+1+MED_NBR_GEOMETRIE_ARETE+MED_NBR_GEOMETRIE_FACE+1][2]=
 479     {
 480       {(med_geometrie_element)MED_NOEUD,(med_geometrie_element)0},
 481       {(med_geometrie_element)MED_MAILLE,MED_POINT1   },
 482       {(med_geometrie_element)MED_MAILLE,MED_SEG2     },
 483       {(med_geometrie_element)MED_MAILLE,MED_SEG3     },
 484       {(med_geometrie_element)MED_MAILLE,MED_TRIA3    },
 485       {(med_geometrie_element)MED_MAILLE,MED_TRIA6    },
 486       {(med_geometrie_element)MED_MAILLE,MED_QUAD4    },
 487       {(med_geometrie_element)MED_MAILLE,MED_QUAD8    },
 488       {(med_geometrie_element)MED_MAILLE,MED_POLYGONE },
 489       {(med_geometrie_element)MED_ARETE ,MED_SEG2     },
 490       {(med_geometrie_element)MED_ARETE ,MED_SEG3     },
 491       {(med_geometrie_element)MED_FACE  ,MED_TRIA3    },
 492       {(med_geometrie_element)MED_FACE  ,MED_TRIA6    },
 493       {(med_geometrie_element)MED_FACE  ,MED_QUAD4    },
 494       {(med_geometrie_element)MED_FACE  ,MED_QUAD8    },
 495       {(med_geometrie_element)MED_FACE  ,MED_POLYGONE }
 496     };
 497   char nom_geo_ent[1+NBR_MAILLE_EQU+1+MED_NBR_GEOMETRIE_ARETE+MED_NBR_GEOMETRIE_FACE+1][MED_TAILLE_NOM+1] =
 498     {
 499       "MED_NOEUD           ",
 500       "MED_MAILLE:MED_POINT1   ",
 501       "MED_MAILLE:MED_SEG2     ",
 502       "MED_MAILLE:MED_SEG3     ",
 503       "MED_MAILLE:MED_TRIA3    ",
 504       "MED_MAILLE:MED_TRIA6    ",
 505       "MED_MAILLE:MED_QUAD4    ",
 506       "MED_MAILLE:MED_QUAD8    ",
 507       "MED_MAILLE:MED_POLYGONE ",
 508       "MED_ARETE :MED_SEG2     ",
 509       "MED_ARETE :MED_SEG3     ",
 510       "MED_FACE  :MED_TRIA3    ",
 511       "MED_FACE  :MED_TRIA6    ",
 512       "MED_FACE  :MED_QUAD4    ",
 513       "MED_FACE  :MED_QUAD8    ",
 514       "MED_FACE  :MED_POLYGONE "
 515     };
 516   med_err ret = 0;
 517 
 518   fprintf(stdout,"\n(******************************)\n");
 519   fprintf(stdout,"(* JOINTS DU MAILLAGE       : *)\n");
 520   fprintf(stdout,"(******************************)\n");
 521 
 522   if (njnt == 0)
 523     fprintf(stdout,"- Aucun joint \n");
 524 
 525   /* lecture de touts les joints associes a nommaa */
 526   for (i = 0;i<njnt;i++) {
 527     fprintf(stdout,"- Joint numero : %d ",i+1);
 528 
 529     /* lecture des infos sur le joint */
 530     ret=MEDjointInfo(fid,nommaa,i+1,jn,des,&ndom,maa_dist);
 531     EXIT_IF(ret < 0,"lors de la lecture des informations sur un joint",
 532             NULL);
 533     fprintf(stdout,"\n  - Nom du joint: %s \n",jn);
 534     fprintf(stdout,"\n  - Description du joint      : %s ",des);
 535     fprintf(stdout,"\n  - Domaine en regard         : %d ",ndom);
 536     fprintf(stdout,"\n  - Maillage distant          : %s ",maa_dist);
 537 
 538 
 539     /* lecture des correspondances sur les differents types d'entites */
 540     /* recherche du type des entites en regard... passage par toutes les combinaisons */
 541     for (geo_ent_local=0;geo_ent_local<nb_geo_ent;geo_ent_local++) {
 542         for (geo_ent_distant=0;geo_ent_distant<nb_geo_ent;geo_ent_distant++) {
 543           typ_ent_local = typ_geo_ent[geo_ent_local][0];
 544           typ_geo_local = typ_geo_ent[geo_ent_local][1];
 545           typ_ent_distant = typ_geo_ent[geo_ent_distant][0];
 546           typ_geo_distant = typ_geo_ent[geo_ent_distant][1];
 547 
 548           if (nent=MEDjointnCorres(fid,nommaa,jn,(med_entite_maillage)typ_ent_local,(med_geometrie_element)typ_geo_local,
 549                                    (med_entite_maillage)typ_ent_distant,(med_geometrie_element)typ_geo_distant)) {
 550             if (nent > 0) {
 551               fprintf(stdout,"\n\t\t- nb de couples d'entites en regard (local,distant)=(%s,%s) : %d \n",
 552                       nom_geo_ent[geo_ent_local],nom_geo_ent[geo_ent_distant],
 553                       nent);
 554               fprintf(stdout,"  %d \n",nent);
 555               cortab = (med_int*) malloc(sizeof(med_int)*nent*2);
 556               if (MEDjointLire(fid,nommaa,jn,cortab,nent*2,
 557                                    (med_entite_maillage)typ_ent_local,(med_geometrie_element)typ_geo_local,
 558                    (med_entite_maillage)typ_ent_distant,(med_geometrie_element)typ_geo_distant) < 0) {
 559                 fprintf(stdout,"\n\t\t- Erreur a la lecture des correspondances sur (%d,%d,%d,%d)",
 560                         typ_ent_local,typ_geo_local,typ_ent_distant,typ_geo_distant,0);
 561               }
 562               else {
 563             if (!structure) {
 564                 for (k=0;k<nent;k++)
 565                   fprintf(stdout,"\n\t\t- Correspondance %d : %d et %d ",k+1,
 566                           *(cortab+2*k),*(cortab+2*k+1));
 567                         }
 568               }
 569               free(cortab);
 570             }
 571 
 572           }
 573         }
 574       }
 575   }
 576 
 577   return;
 578 }
 579 
 580 
 581 med_int lecture_nombre_noeuds_maillage_non_structure(med_idt fid,
 582                                                      char *nommaa)
 583 {
 584   med_int nnoe = MEDnEntMaa(fid,nommaa,MED_COOR,MED_NOEUD,(med_geometrie_element)0,(med_connectivite)0);
 585   EXIT_IF(nnoe < 0,"lors de la lecture du nombre de noeuds",NULL);
 586   fprintf(stdout,"- Nombre de noeuds : %d \n",nnoe);
 587 
 588   return nnoe;
 589 }
 590 
 591 
 592 void lecture_noeuds_maillage_non_structure(med_idt fid,
 593                                            char *nommaa,
 594                                            med_int mdim,
 595                                            med_int nnoe,
 596                                            med_mode_switch mode_coo)
 597 {
 598   med_float *coo;
 599   char nomcoo[3*MED_TAILLE_PNOM+1];
 600   char unicoo[3*MED_TAILLE_PNOM+1];
 601   char *nomnoe;
 602   med_int *numnoe;
 603   med_int *nufano;
 604   med_repere rep;
 605   med_booleen inonoe,inunoe;
 606   med_err ret = 0;
 607   med_int i;
 608   char str[MED_TAILLE_PNOM+1];
 609 
 610   /* Allocations memoires */
 611   /* table des coordonnees
 612      profil : (dimension * nombre de noeuds ) */
 613   coo = (med_float*) malloc(sizeof(med_float)*nnoe*mdim);
 614   EXIT_IF(coo == NULL,NULL,NULL);
 615   /* table  des numeros, des numeros de familles des noeuds
 616      profil : (nombre de noeuds) */
 617   numnoe = (med_int*) malloc(sizeof(med_int)*nnoe);
 618   EXIT_IF(numnoe == NULL,NULL,NULL);
 619   nufano = (med_int*) malloc(sizeof(med_int)*nnoe);
 620   EXIT_IF(nufano == NULL,NULL,NULL);
 621   /* table des noms des noeuds
 622      profil : (nnoe*MED_TAILLE_PNOM+1) */
 623   nomnoe = (char*) malloc(MED_TAILLE_PNOM*nnoe+1);
 624   EXIT_IF(nomnoe == NULL,NULL,NULL);
 625 
 626   /* lecture des noeuds :
 627      - coordonnees
 628      - noms (optionnel dans un fichier MED)
 629      - numeros (optionnel dans un fichier MED)
 630      - numeros des familles */
 631   ret = MEDnoeudsLire(fid,nommaa,mdim,coo,mode_coo,&rep,
 632                       nomcoo,unicoo,nomnoe,&inonoe,numnoe,&inunoe,
 633                       nufano,nnoe);
 634   EXIT_IF(ret < 0,"lors de la lecture des noeuds du maillage \n",NULL);
 635 
 636   /* affichage des resultats */
 637   fprintf(stdout,"\n(************************)\n");
 638   fprintf(stdout,"(* NOEUDS DU MAILLAGE : *)\n");
 639   fprintf(stdout,"(************************)\n");
 640   fprintf(stdout,"- Type de repere des coordonnees : %d \n",rep);
 641   fprintf(stdout,"- Nom des coordonnees : \n");
 642   for (i=0;i<mdim;i++) {
 643     strncpy(str,nomcoo+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
 644     str[MED_TAILLE_PNOM] = '\0';
 645     fprintf(stdout," %s ",str);
 646   }
 647   fprintf(stdout,"\n- Unites des coordonnees : \n");
 648   for (i=0;i<mdim;i++) {
 649     strncpy(str,unicoo+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
 650     str[MED_TAILLE_PNOM] = '\0';
 651     fprintf(stdout," %s ",str);
 652   }
 653   if (!structure) {
 654   fprintf(stdout,"\n- Coordonnees des noeuds : \n");
 655   for (i=0;i<nnoe*mdim;i++) {
 656     if (mode_coo == MED_FULL_INTERLACE && !(i % mdim))
 657       fprintf(stdout,"\n [ %5d ] : ", (i/mdim + 1) );
 658     if (mode_coo == MED_NO_INTERLACE && ! (i % nnoe))
 659       fprintf(stdout,"\n\n ");
 660     fprintf(stdout," %-+9.6f ",*(coo+i));
 661   }
 662 
 663   if (inonoe) {
 664     fprintf(stdout,"\n- Noms des noeuds : \n");
 665     for (i=0;i<nnoe;i++) {
 666       strncpy(str,nomnoe+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
 667       str[MED_TAILLE_PNOM] = '\0';
 668       fprintf(stdout," %s ",str);
 669     }
 670   }
 671   if (inunoe) {
 672     fprintf(stdout,"\n- Numeros des noeuds : \n");
 673     for (i=0;i<nnoe;i++)
 674       fprintf(stdout," %d ",*(numnoe+i));
 675   }
 676   fprintf(stdout,"\n- Numeros des familles des noeuds : \n");
 677   for (i=0;i<nnoe;i++)
 678     fprintf(stdout," %d ",*(nufano+i));
 679   fprintf(stdout,"\n");
 680   }
 681 
 682 
 683   /* liberation memoire */
 684   free(coo);
 685   free(nomnoe);
 686   free(numnoe);
 687   free(nufano);
 688 
 689   return;
 690 }
 691 
 692 
 693 med_int lecture_nombre_mailles_standards(med_idt fid,
 694                                          char *nommaa,
 695                                          med_geometrie_element typ_geo,
 696                                          med_connectivite typ_con,
 697                                          const int indice)
 698 {
 699     med_int nmailles = MEDnEntMaa(fid,nommaa,MED_CONN,MED_MAILLE,
 700                                   typ_geo,typ_con);
 701     EXIT_IF(nmailles < 0," lors de la lecture du nombre de mailles",NULL);
 702     fprintf (stdout,"- Nombre de mailles de type %s : %d \n",nommai[indice],
 703              nmailles);
 704 
 705     return nmailles;
 706 }
 707 
 708 void lecture_mailles_standards(med_idt fid,
 709                                char *nommaa,
 710                                med_int mdim,
 711                                med_int *nmailles,
 712                                med_mode_switch mode_coo,
 713                                med_connectivite typ_con)
 714 {
 715   med_int taille;
 716   med_int *connectivite;
 717   char *nomele;
 718   med_int *numele;
 719   med_int *nufael;
 720   med_booleen inoele, inuele;
 721   med_geometrie_element typgeo;
 722   med_int desmai[MED_NBR_GEOMETRIE_MAILLE] = {0,2,3,3,3,4,4,4,4,6,6,5,5,5,5};
 723   med_int i,j;
 724   med_err ret = 0;
 725   char str[MED_TAILLE_PNOM+1];
 726 
 727   fprintf(stdout,"\n(**************************)\n");
 728   fprintf(stdout,"(* ELEMENTS DU MAILLAGE : *)\n");
 729   fprintf(stdout,"(**************************)");
 730 
 731   /* Lecture des connectivites, noms, numeros des mailles */
 732   for (i=0;i<MED_NBR_GEOMETRIE_MAILLE;i++)
 733     if (nmailles[i] > 0) {
 734 
 735       switch(typ_con) {
 736       case MED_NOD :
 737         taille = typmai[i]%100;
 738         break;
 739 
 740       case MED_DESC :
 741         taille = desmai[i];
 742         break;
 743 
 744       default :
 745         ret = -1;
 746       }
 747 
 748       /* allocation memoire */
 749       connectivite = (med_int*) malloc(sizeof(med_int)*taille*nmailles[i]);
 750       EXIT_IF(connectivite == NULL,NULL,NULL);
 751       nomele = (char*) malloc(sizeof(char)*MED_TAILLE_PNOM*nmailles[i]+1);
 752       EXIT_IF(nomele == NULL,NULL,NULL);
 753       numele = (med_int*) malloc(sizeof(med_int)*nmailles[i]);
 754       EXIT_IF(numele == NULL,NULL,NULL);
 755       nufael = (med_int*) malloc(sizeof(med_int)*nmailles[i]);
 756       EXIT_IF(nufael == NULL,NULL,NULL);
 757 
 758       /* lecture des données */
 759       ret = MEDelementsLire(fid,nommaa,mdim,connectivite,mode_coo,
 760                             nomele,&inoele,numele,&inuele,nufael,
 761                             nmailles[i],MED_MAILLE,typmai[i],typ_con);
 762       EXIT_IF(ret < 0,"lors de la lecture des mailles",NULL);
 763 
 764       if (!structure) {
 765       /* affichage des resultats */
 766       fprintf(stdout,"\n\n- Mailles de type %s : ", nommai[i]);
 767       fprintf(stdout,"\n  - Connectivité : \n");
 768       for (j=0;j<nmailles[i]*taille;j++) {
 769             if (mode_coo == MED_FULL_INTERLACE && !(j % taille))
 770               fprintf(stdout,"\n [ %5d ] : ", (j/taille +1) );
 771             if (mode_coo == MED_NO_INTERLACE && !(j % nmailles[i]))
 772               fprintf(stdout,"\n");
 773             fprintf(stdout," %9d ",*(connectivite+j));
 774       }
 775 
 776       if (inoele) {
 777         fprintf(stdout,"\n  - Noms : \n");
 778         for (j=0;j<nmailles[i];j++) {
 779           strncpy(str,nomele+j*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
 780           str[MED_TAILLE_PNOM] = '\0';
 781           fprintf(stdout," %s ",str);
 782         }
 783       }
 784       if (inuele) {
 785         fprintf(stdout,"\n  - Numeros :\n");
 786         for (j=0;j<nmailles[i];j++)
 787           fprintf(stdout," %d ",*(numele+j));
 788       }
 789       fprintf(stdout,"\n  - Numéros de familles : \n");
 790       for (j=0;j<nmailles[i];j++)
 791         fprintf(stdout," %d ",*(nufael+j));
 792           }
 793 
 794       /* liberation memoire */
 795       free(connectivite);
 796       free(nomele);
 797       free(numele);
 798       free(nufael);
 799     }
 800 
 801   return;
 802 }
 803 
 804 
 805 med_int lecture_nombre_mailles_polygones(med_idt fid,
 806                                          char *nommaa,
 807                                          med_connectivite typ_con)
 808 {
 809   med_int nmpolygones = MEDnEntMaa(fid,nommaa,MED_CONN,MED_MAILLE,
 810                                    MED_POLYGONE,typ_con);
 811   EXIT_IF(nmpolygones < 0,"lors de la lecture du nombre de mailles polygone\n",
 812           NULL);
 813   fprintf(stdout,"- Nombre de mailles de type MED_POLYGONE : %d \n",
 814           nmpolygones);
 815 
 816   return nmpolygones;
 817 }
 818 
 819 void lecture_mailles_polygones(med_idt fid,
 820                                char *nommaa,
 821                                med_int nmpolygones,
 822                                med_mode_switch mode_coo,
 823                                med_connectivite typ_con)
 824 {
 825   med_int i,j;
 826   med_err ret = 0;
 827   med_int taille;
 828   med_int *connectivite;
 829   char *nomele;
 830   med_int *numele;
 831   med_int *nufael;
 832   med_int *indexp;
 833   int ind1,ind2,np;
 834   med_int nf;
 835   char tmp[MED_TAILLE_NOM+1];
 836   med_err ret1,ret2,ret3;
 837   med_int nfa;
 838 
 839   /* lecture des mailles de type MED_POLYGONE */
 840 
 841   /* quelle taille pour  le tableau des connectivites ? */
 842   ret = MEDpolygoneInfo(fid,nommaa,MED_MAILLE,typ_con,&taille);
 843   EXIT_IF(ret < 0,"lors de la lecture des parametres des mailles polygones",
 844           NULL);
 845 
 846   /* allocation memoire */
 847   indexp = (med_int *) malloc(sizeof(med_int)*(nmpolygones+1));
 848   EXIT_IF(indexp == NULL,NULL,NULL);
 849   connectivite = (med_int *) malloc(sizeof(med_int)*taille);
 850   EXIT_IF(connectivite == NULL,NULL,NULL);
 851   numele = (med_int *) malloc(sizeof(med_int)*nmpolygones);
 852   EXIT_IF(numele == NULL,NULL,NULL);
 853   nufael = (med_int *) malloc(sizeof(med_int)*nmpolygones);
 854   EXIT_IF(nufael == NULL,NULL,NULL);
 855   nomele = (char *) malloc(sizeof(char)*MED_TAILLE_PNOM*nmpolygones+1);
 856   EXIT_IF(nomele == NULL,NULL,NULL);
 857 
 858   /* lecture de la connectivite des mailles polygones */
 859   ret = MEDpolygoneConnLire(fid,nommaa,indexp,nmpolygones+1,connectivite,
 860                               MED_MAILLE,typ_con);
 861   EXIT_IF(ret < 0,"lors de la lecture des connectivites des mailles polygones",
 862           NULL);
 863 
 864   /* lecture noms */
 865   ret1 = MEDnomLire(fid,nommaa,nomele,nmpolygones,MED_MAILLE,MED_POLYGONE);
 866 
 867   /* lecture des numeros */
 868   ret2 = (med_int) MEDnumLire(fid,nommaa,numele,nmpolygones,
 869                               MED_MAILLE,MED_POLYGONE);
 870 
 871   /* lecture des numeros de familles */
 872   ret3 = MEDfamLire(fid,nommaa,nufael,nmpolygones,MED_MAILLE,MED_POLYGONE);
 873 
 874   if (!structure) {
 875   /* affichage des resultats */
 876   fprintf(stdout,"\n\n- Mailles de type MED_POLYGONE : ");
 877     for (i=0;i<nmpolygones;i++) {
 878       fprintf(stdout,"\n >> Maille MED_POLYGONE %d : \n",i+1);
 879       fprintf(stdout,"\n  - Connectivité : ");
 880       ind1 = *(indexp+i)-1;
 881       ind2 = *(indexp+i+1)-1;
 882       for (j=ind1;j<ind2;j++)
 883         printf(" %d ",*(connectivite+j));
 884       if (ret1 == 0) {
 885         strncpy(tmp,nomele+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
 886         tmp[MED_TAILLE_PNOM] = '\0';
 887         fprintf(stdout,"\n  - Nom : %s \n",tmp);
 888       }
 889       if (ret2 == 0)
 890         fprintf(stdout,"\n  - Numero : %d \n",*(numele+i));
 891       fprintf(stdout,"\n  - Numéro de famille : %d \n",*(nufael+i));
 892     }
 893   }
 894 
 895     /* on libere la memoire */
 896     free(indexp);
 897     free(connectivite);
 898     free(numele);
 899     free(nufael);
 900     free(nomele);
 901 
 902     return;
 903 }
 904 
 905 
 906 med_int lecture_nombre_mailles_polyedres(med_idt fid,
 907                                          char *nommaa,
 908                                          med_connectivite typ_con)
 909 {
 910   med_int npolyedres = MEDnEntMaa(fid,nommaa,MED_CONN,MED_MAILLE,
 911                                   MED_POLYEDRE,typ_con);
 912   EXIT_IF(npolyedres < 0,"lors de la lecture du nombre de mailles polyedre \n",
 913           NULL);
 914   fprintf(stdout,"- Nombre de mailles de type MED_POLYEDRE : %d \n",
 915           npolyedres);
 916 
 917   return npolyedres;
 918 }
 919 
 920 
 921 void lecture_mailles_polyedres(med_idt fid,
 922                                char *nommaa,
 923                                med_int npolyedres,
 924                                med_mode_switch mode_coo,
 925                                med_connectivite typ_con)
 926 {
 927   med_int i,j,k;
 928   med_err ret = 0;
 929   med_int taille;
 930   med_int *connectivite;
 931   char *nomele;
 932   med_int *numele;
 933   med_int *nufael;
 934   med_int *indexp, *indexf;
 935   int ind1,ind2,np;
 936   med_int nf;
 937   char tmp[MED_TAILLE_PNOM+1];
 938   med_err ret1,ret2,ret3;
 939   med_int nfa;
 940   med_int nnoe;
 941 
 942 
 943   /* lecture des parametres de base */
 944   ret = MEDpolyedreInfo(fid,nommaa,typ_con,&nf,&taille);
 945   EXIT_IF(ret < 0,"lors de la lecture des parametres des mailles polyedres0",
 946           NULL);
 947 
 948   /* allocation memoire */
 949   indexp = (med_int *) malloc(sizeof(med_int)*(npolyedres+1));
 950   EXIT_IF(indexp == NULL,NULL,NULL);
 951   indexf = (med_int *) malloc(sizeof(med_int)*nf);
 952   EXIT_IF(indexf == NULL,NULL,NULL);
 953   connectivite  = (med_int *) malloc(sizeof(med_int)*taille);
 954   EXIT_IF(connectivite == NULL,NULL,NULL);
 955   numele = (med_int *) malloc(sizeof(med_int)*npolyedres);
 956   EXIT_IF(numele == NULL,NULL,NULL);
 957   nufael = (med_int *) malloc(sizeof(med_int)*npolyedres);
 958   EXIT_IF(nufael == NULL,NULL,NULL);
 959   nomele = (char *) malloc(sizeof(char)*MED_TAILLE_PNOM*npolyedres+1);
 960   EXIT_IF(nomele == NULL,NULL,NULL);
 961 
 962   /* lecture de la connectivite des mailles polyedres */
 963   ret = MEDpolyedreConnLire(fid,nommaa,indexp,npolyedres+1,indexf,nf,
 964                             connectivite,typ_con);
 965   EXIT_IF(ret < 0,
 966           "lors de la lecture de la connectivite des mailles polyedres",
 967           NULL);
 968 
 969   /* lecture des noms */
 970   ret1 = MEDnomLire(fid,nommaa,nomele,npolyedres,MED_MAILLE,MED_POLYEDRE);
 971 
 972   /* lecture des numeros */
 973   ret2 = MEDnumLire(fid,nommaa,numele,npolyedres,MED_MAILLE,MED_POLYEDRE);
 974 
 975   /* lecture des numeros de familles */
 976   ret3 = MEDfamLire(fid,nommaa,nufael,npolyedres,MED_MAILLE,MED_POLYEDRE);
 977 
 978   if (!structure) {
 979   /* affichage des resultats */
 980   fprintf(stdout,"\n\n- Mailles de type MED_POLYEDRE : ");
 981   for (i=0;i<npolyedres;i++) {
 982     fprintf(stdout,"\n >> Maille MED_POLYEDRE %d : \n",i+1);
 983     fprintf(stdout,"\n  - Connectivité : \n");
 984     nfa  = *(indexp+i+1) - *(indexp+i);
 985     /* ind1 = indice dans "indexf" pour acceder aux numeros des faces */
 986     ind1 = *(indexp+i) - 1;
 987     for (j=0;j<nfa;j++) {
 988       if (typ_con == MED_NOD) {
 989         /* ind2 = indice dans "connectivite"
 990            pour acceder au premier noeud de la face */
 991         ind2 = *(indexf+ind1+j) - 1;
 992         nnoe = *(indexf+ind1+j+1) - *(indexf+ind1+j);
 993         fprintf(stdout,"   - Face %d : [ ", j+1);
 994         for (k=0;k<nnoe;k++)
 995           printf(" %d ",*(connectivite+ind2+k));
 996         printf(" ] \n");
 997       }
 998       else {
 999         nfa  = *(indexp+i+1) - *(indexp+i);
1000         /* ind1 = indice dans "connectivite"
1001            pour acceder aux numeros des faces */
1002         ind1 = *(indexp+i) - 1;
1003         for (j=0;j<nfa;j++)
1004           fprintf(stdout,"   - Face %d de numero : %d et de type %d \n", j+1,
1005                   *(connectivite+ind1+j),*(indexf+ind1+j));
1006       }
1007     }
1008     if (ret1 == 0) {
1009       strncpy(tmp,nomele+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
1010       tmp[MED_TAILLE_PNOM] = '\0';
1011       fprintf(stdout,"\n  - Nom : %s \n",tmp);
1012     }
1013     if (ret2 == 0)
1014       fprintf(stdout,"\n  - Numero : %d \n",*(numele+i));
1015     fprintf(stdout,"\n  - Numéro de famille : %d \n",*(nufael+i));
1016   }
1017   }
1018 
1019   /* on libere la memoire */
1020   free(indexp);
1021   free(indexf);
1022   free(connectivite);
1023   free(numele);
1024   free(nufael);
1025   free(nomele);
1026 
1027   return;
1028 }
1029 
1030 med_int lecture_nombre_faces_standards(med_idt fid,
1031                                        char *nommaa,
1032                                        med_geometrie_element typ_geo,
1033                                        const med_int indice
1034                                        )
1035 {
1036   med_int nfaces = MEDnEntMaa(fid,nommaa,MED_CONN,MED_FACE,typ_geo,
1037                               MED_DESC);
1038   EXIT_IF(nfaces < 0,"lors de la lecture du nombre de faces",NULL);
1039   fprintf (stdout,"- Nombre de faces de type %s : %d \n",
1040            nomfac[indice],nfaces);
1041 
1042   return nfaces;
1043 }
1044 
1045 void lecture_faces_standard(med_idt fid,
1046                             char *nommaa,
1047                             med_int mdim,
1048                             med_int *nfaces,
1049                             med_mode_switch mode_coo)
1050 {
1051   med_int taille;
1052   med_int *connectivite;
1053   char *nomele;
1054   med_int *numele;
1055   med_int *nufael;
1056   med_booleen inoele,inuele;
1057   med_geometrie_element typgeo;
1058   med_int i,j;
1059   med_err ret = 0;
1060   char str[MED_TAILLE_PNOM+1];
1061   med_int desfac[MED_NBR_GEOMETRIE_FACE] = {3,3,4,4};
1062 
1063   for (i=0;i<MED_NBR_GEOMETRIE_FACE;i++)
1064     if (nfaces[i] > 0 ) {
1065 
1066       /*  taille de la description : nombre d'aretes */
1067       taille = desfac[i];
1068 
1069       /* allocation memoire */
1070       connectivite = (med_int*)malloc(sizeof(med_int)*taille*nfaces[i]);
1071       EXIT_IF(connectivite == NULL,NULL,NULL);
1072       nomele = (char*)malloc(sizeof(char)*MED_TAILLE_PNOM*nfaces[i]+1);
1073       EXIT_IF(nomele == NULL,NULL,NULL);
1074       numele = (med_int*)malloc(sizeof(med_int)*nfaces[i]);
1075       EXIT_IF(numele == NULL,NULL,NULL);
1076       nufael = (med_int*)malloc(sizeof(med_int)*nfaces[i]);
1077       EXIT_IF(nufael == NULL,NULL,NULL);
1078 
1079       /* lecture des données */
1080       ret = MEDelementsLire(fid,nommaa,mdim,connectivite,mode_coo,
1081                             nomele,&inoele,numele,&inuele,nufael,
1082                             nfaces[i],MED_FACE,typfac[i],
1083                             MED_DESC);
1084       EXIT_IF(ret < 0,"lors de la lecture des faces",NULL);
1085 
1086       if (!structure) {
1087       /* affichage des resultats */
1088       fprintf(stdout,"\n- Faces de type %s : ", nomfac[i]);
1089       fprintf(stdout,"\n  - Connectivité : \n");
1090       for (j=0;j<nfaces[i]*taille;j++) {
1091             if (mode_coo == MED_FULL_INTERLACE && !(j % taille))
1092               fprintf(stdout,"\n [ %5d ] : ", (j/taille+1) );
1093             if (mode_coo == MED_NO_INTERLACE && !(j % nfaces[i]))
1094               fprintf(stdout,"\n");
1095             fprintf(stdout," %9d ",*(connectivite+j));
1096           }
1097 
1098       if (inoele) {
1099         fprintf(stdout,"\n  - Noms : \n");
1100         for (j=0;j<nfaces[i];j++) {
1101           strncpy(str,nomele+j*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
1102           str[MED_TAILLE_PNOM] = '\0';
1103           fprintf(stdout," %s ",str);
1104         }
1105       }
1106       if (inuele) {
1107         fprintf(stdout,"\n  - Numeros :\n");
1108         for (j=0;j<nfaces[i];j++)
1109           fprintf(stdout," %d ",*(numele+j));
1110       }
1111       fprintf(stdout,"\n  - Numéros de familles : \n");
1112       for (j=0;j<nfaces[i];j++)
1113         fprintf(stdout," %d ",*(nufael+j));
1114           }
1115 
1116       /* liberation memoire */
1117       free(connectivite);
1118       free(nomele);
1119       free(numele);
1120       free(nufael);
1121     }
1122 
1123   return;
1124 }
1125 
1126 med_int lecture_nombre_faces_polygones(med_idt fid,
1127                                        char *nommaa)
1128 {
1129   med_int nfpolygones = MEDnEntMaa(fid,nommaa,MED_CONN,MED_FACE,MED_POLYGONE,
1130                                    MED_DESC);
1131   EXIT_IF(nfpolygones < 0,"lors de la lecture du nombre de faces polygone \n",
1132           NULL);
1133   fprintf(stdout,"- Nombre de faces de type MED_POLYGONE : %d \n",
1134           nfpolygones);
1135 
1136   return nfpolygones;
1137 }
1138 
1139 void lecture_faces_polygones(med_idt fid,
1140                              char *nommaa,
1141                              med_int nfpolygones,
1142                              med_mode_switch mode_coo)
1143 {
1144   med_int i,j;
1145   med_err ret = 0;
1146   char *nomele;
1147   med_int *numele;
1148   med_int *nufael;
1149   med_int *connectivite;
1150   med_int taille;
1151   med_int *indexp;
1152   int ind1,ind2,np;
1153   med_int nf;
1154   char tmp[MED_TAILLE_NOM+1];
1155   med_err ret1,ret2,ret3;
1156   med_int nfa;
1157 
1158   /* quelle taille pour  le tableau des connectivites ? */
1159   ret = MEDpolygoneInfo(fid,nommaa,MED_FACE,MED_DESC,&taille);
1160   EXIT_IF(ret < 0,"lors de la lecture des parametres des faces polygones",
1161             NULL);
1162 
1163   /* allocation memoire */
1164   indexp = (med_int *) malloc(sizeof(med_int)*(nfpolygones+1));
1165   EXIT_IF(indexp == NULL,NULL,NULL);
1166   connectivite = (med_int *) malloc(sizeof(med_int)*taille);
1167   EXIT_IF(connectivite == NULL,NULL,NULL);
1168   numele = (med_int *) malloc(sizeof(med_int)*nfpolygones);
1169   EXIT_IF(numele == NULL,NULL,NULL);
1170   nufael = (med_int *) malloc(sizeof(med_int)*nfpolygones);
1171   EXIT_IF(nufael == NULL,NULL,NULL);
1172   nomele = (char *) malloc(sizeof(char)*MED_TAILLE_PNOM*nfpolygones+1);
1173   EXIT_IF(nomele == NULL,NULL,NULL);
1174 
1175   /* lecture de la connectivite des faces polygones */
1176   ret = MEDpolygoneConnLire(fid,nommaa,indexp,nfpolygones+1,connectivite,
1177                             MED_FACE,MED_DESC);
1178   EXIT_IF(ret < 0,"lors de la lecture des connectivites des faces polygones",
1179           NULL);
1180 
1181   /* lecture des noms */
1182   ret1 = MEDnomLire(fid,nommaa,nomele,nfpolygones,
1183                     MED_FACE,MED_POLYGONE);
1184 
1185   /* lecture des numeros */
1186   ret2 = (med_int) MEDnumLire(fid,nommaa,numele,nfpolygones,
1187                               MED_FACE,MED_POLYGONE);
1188 
1189   /* lecture des numeros de familles */
1190   ret3 = MEDfamLire(fid,nommaa,nufael,nfpolygones,MED_FACE,MED_POLYGONE);
1191 
1192   if (!structure) {
1193   /* affichage des resultats */
1194   fprintf(stdout,"\n\n- Faces de type MED_POLYGONE : ");
1195   for (i=0;i<nfpolygones;i++) {
1196     fprintf(stdout,"\n >> Face MED_POLYGONE %d : \n",i+1);
1197     fprintf(stdout,"\n  - Connectivité : ");
1198     ind1 = *(indexp+i)-1;
1199     ind2 = *(indexp+i+1)-1;
1200     for (j=ind1;j<ind2;j++)
1201       fprintf(stdout," %d ",*(connectivite+j));
1202     if (ret1 == 0) {
1203       strncpy(tmp,nomele+j*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
1204       tmp[MED_TAILLE_PNOM] = '\0';
1205       fprintf(stdout,"\n  - Nom : %s \n",tmp);
1206     }
1207     if (ret2 == 0)
1208       fprintf(stdout,"\n  - Numero : %d \n",*(numele+j));
1209     fprintf(stdout,"\n  - Numéro de famille : %d \n",*(nufael+j));
1210   }
1211   }
1212 
1213   /* on libere la memoire */
1214   free(indexp);
1215   free(connectivite);
1216   free(numele);
1217   free(nufael);
1218   free(nomele);
1219 
1220   return;
1221 }
1222 
1223 
1224 med_int lecture_nombre_aretes_standards(med_idt fid,
1225                                         char *nommaa,
1226                                         med_geometrie_element typ_geo,
1227                                         const med_int indice)
1228 {
1229   med_int naretes = MEDnEntMaa(fid,nommaa,MED_CONN,MED_ARETE,typ_geo,MED_DESC);
1230   EXIT_IF(naretes < 0,"lors de la lecture du nombre d'aretes",NULL);
1231   fprintf (stdout,
1232            "- Nombre d'aretes de type %s : %d \n",nomare[indice],naretes);
1233 
1234   return naretes;
1235 }
1236 
1237 void lecture_aretes_standards(med_idt fid,
1238                               char *nommaa,
1239                               med_int mdim,
1240                               med_int *naretes,
1241                               med_mode_switch mode_coo)
1242 {
1243   med_int taille;
1244   med_int *connectivite;
1245   char *nomele;
1246   med_int *numele;
1247   med_int *nufael;
1248   med_booleen inoele,inuele;
1249   med_geometrie_element typgeo;
1250   med_int desare[MED_NBR_GEOMETRIE_ARETE] = {2,3};
1251   med_int i,j;
1252   med_err ret = 0;
1253   char str[MED_TAILLE_PNOM+1];
1254 
1255   for (i=0;i<MED_NBR_GEOMETRIE_ARETE;i++)
1256     if (naretes[i] > 0) {
1257 
1258       taille = desare[i];
1259       /* dimension de l'arete  */
1260       /* edim = typare[i] / 100; */
1261 
1262       /* allocation memoire */
1263       connectivite = (med_int*)malloc(sizeof(med_int)*taille*naretes[i]);
1264       EXIT_IF(connectivite == NULL,NULL,NULL);
1265       nomele = (char*)malloc(sizeof(char)*MED_TAILLE_PNOM*naretes[i]+1);
1266       EXIT_IF(nomele == NULL,NULL,NULL);
1267       numele = (med_int*)malloc(sizeof(med_int)*naretes[i]);
1268       EXIT_IF(numele == NULL,NULL,NULL);
1269       nufael = (med_int*)malloc(sizeof(med_int)*naretes[i]);
1270       EXIT_IF(nufael == NULL,NULL,NULL);
1271 
1272       /* lecture des données */
1273       ret = MEDelementsLire(fid,nommaa,mdim,connectivite,mode_coo,
1274                             nomele,&inoele,numele,&inuele,nufael,
1275                             naretes[i],MED_ARETE,typare[i],
1276                             MED_DESC);
1277       EXIT_IF(ret < 0,"lors de la lecture des aretes",
1278               NULL);
1279 
1280       if (!structure) {
1281       /* affichage des resultats */
1282       fprintf(stdout,"\n- Aretes de type %s : ", nomare[i]);
1283       fprintf(stdout,"\n  - Connectivité : \n");
1284       for (j=0;j<naretes[i]*taille;j++) {
1285             if (mode_coo == MED_FULL_INTERLACE && !(j % taille))
1286               fprintf(stdout,"\n [ %5d ] : ", (j/taille+1) );
1287             if (mode_coo == MED_NO_INTERLACE && !(j % naretes[i]))
1288               fprintf(stdout,"\n");
1289             fprintf(stdout," %9d ",*(connectivite+j));
1290           }
1291 
1292       if (inoele) {
1293         fprintf(stdout,"\n  - Noms : \n");
1294         for (j=0;j<naretes[i];j++) {
1295           strncpy(str,nomele+j*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
1296           str[MED_TAILLE_PNOM] = '\0';
1297           fprintf(stdout," %s ",str);
1298         }
1299       }
1300       if (inuele) {
1301         fprintf(stdout,"\n  - Numeros :\n");
1302         for (j=0;j<naretes[i];j++)
1303           fprintf(stdout," %d ",*(numele+j));
1304       }
1305       fprintf(stdout,"\n  - Numéros de familles : \n");
1306       for (j=0;j<naretes[i];j++)
1307         fprintf(stdout," %d ",*(nufael+j));
1308           }
1309 
1310       /* liberation memoire */
1311       free(connectivite);
1312       free(nomele);
1313       free(numele);
1314       free(nufael);
1315     }
1316 
1317   return;
1318 }
1319 
1320 
1321 /******************************************************************************
1322  * - Nom de la fonction : lecture_maillage_non_structure
1323  * - Description : lecture et affichage d'un maillage MED_NON_STRUCTURE.
1324  * - Parametres :
1325  *     - fid                       (IN) : ID du fichier MED.
1326  *     - nommaa                    (IN) : nom du maillage a lire.
1327  *     - mdim                      (IN) : dimension du maillage.
1328  *     - mode_coo                  (IN) : mode de stockage en memoire :
1329  *                                        MED_FULL_INTERLACE : entrelace |
1330  *                                        MED_NO_INTERLACE : non entrelace.
1331  *     - typ_con                   (IN) : mode de connectivite :
1332  *                                        MED_DESC : descendante |
1333  *                                        MED_NOD : nodale.
1334  *     - lecture_en_tete_seulement (IN) : mode de lecture et d'affichage.
1335  ******************************************************************************/
1336 
1337 void lecture_maillage_non_structure(med_idt fid,
1338                                     char *nommaa,
1339                                     med_int mdim,
1340                                     med_mode_switch mode_coo,
1341                                     med_connectivite typ_con,
1342                                     const int lecture_en_tete_seulement)
1343 {
1344   med_err ret = 0;
1345   med_int i;
1346   /* nombre d'objets MED : noeuds, mailles, faces, aretes , ... */
1347   med_int nnoe;
1348   med_int nmailles[MED_NBR_GEOMETRIE_MAILLE];
1349   med_int nfaces[MED_NBR_GEOMETRIE_FACE];
1350   med_int naretes[MED_NBR_GEOMETRIE_ARETE];
1351   /* polygones et polyedres */
1352   med_int nmpolygones, npolyedres, nfpolygones;
1353   /* familles */
1354   med_int nfam;
1355   /* equivalences */
1356   med_int nequ;
1357   /* joints */
1358   med_int njnt;
1359 
1360   /* Combien de noeuds dans le maillage ? */
1361   nnoe = lecture_nombre_noeuds_maillage_non_structure(fid,nommaa);
1362 
1363   /* Combien de mailles, faces ou aretes pour chaque type geometrique ? */
1364   for (i=0;i<MED_NBR_GEOMETRIE_MAILLE;i++)
1365     nmailles[i] = lecture_nombre_mailles_standards(fid,nommaa,typmai[i],
1366                                                    typ_con,i);
1367 
1368   /* Combien de mailles polygones quelconques ? */
1369   nmpolygones = lecture_nombre_mailles_polygones(fid,nommaa,typ_con);
1370 
1371   /* Combien de mailles polyedres quelconques ? */
1372   npolyedres = lecture_nombre_mailles_polyedres(fid,nommaa,typ_con);
1373 
1374   /* Pour la connectivite descendante */
1375   if (typ_con == MED_DESC) {
1376 
1377     /* Combien de faces : types geometriques standards ? */
1378     for (i=0;i<MED_NBR_GEOMETRIE_FACE;i++)
1379       nfaces[i] = lecture_nombre_faces_standards(fid,nommaa,typfac[i],i);
1380 
1381     /* Combien de faces polygones quelconques ? */
1382     nfpolygones = lecture_nombre_faces_polygones(fid,nommaa);
1383 
1384     /* Combien d'aretes */
1385     for (i=0;i<MED_NBR_GEOMETRIE_ARETE;i++)
1386       naretes[i] = lecture_nombre_aretes_standards(fid,nommaa,typare[i],i);
1387   }
1388 
1389   /* combien de familles ? */
1390   nfam = lecture_nombre_famille(fid,nommaa);
1391 
1392   /* combien d'equivalences ? */
1393   nequ = lecture_nombre_equivalence(fid,nommaa);
1394 
1395   /* combien de joints ? */
1396   njnt = lecture_nombre_joint(fid,nommaa);
1397 
1398   /* en fonction du mode de lecture, on continue ou non */
1399   if (lecture_en_tete_seulement)
1400     return;
1401 
1402   /****************************************************************************
1403   *                       LECTURE DES NOEUDS                                  *
1404   ****************************************************************************/
1405   lecture_noeuds_maillage_non_structure(fid,nommaa,mdim,nnoe,mode_coo);
1406 
1407 
1408   /****************************************************************************
1409   *                       LECTURE DES ELEMENTS                                *
1410   * Mailles :                                                                 *
1411   * - Types geometriques classiques : MED_SEG2, MED_SEG3, MED_TRIA3, ...      *
1412   * - Polygones quelconques.                                                  *
1413   * - Polyedres quelconques.                                                  *
1414   * Faces (connectivite descendante uniquement) :                             *
1415   * - Types geometriques classiques.                                          *
1416   * - Polygones quelconques.                                                  *
1417   ****************************************************************************/
1418 
1419   /* lecture et affichage des mailles */
1420   lecture_mailles_standards(fid,nommaa,mdim,nmailles,mode_coo,typ_con);
1421 
1422   if (nmpolygones > 0)
1423     lecture_mailles_polygones(fid,nommaa,nmpolygones,mode_coo,typ_con);
1424 
1425   if (npolyedres > 0)
1426     lecture_mailles_polyedres(fid,nommaa,npolyedres,mode_coo,typ_con);
1427 
1428   /* lecture et affichage des faces en connectivite descendante uniquement */
1429   if (typ_con == MED_DESC) {
1430     lecture_faces_standard(fid,nommaa,mdim,nfaces,mode_coo);
1431     if (nfpolygones > 0)
1432       lecture_faces_polygones(fid,nommaa,nfpolygones,mode_coo);
1433   }
1434 
1435   /* lecture et affichage des aretes en connectivite descendante uniquement */
1436   if (typ_con == MED_DESC)
1437     lecture_aretes_standards(fid,nommaa,mdim,naretes,mode_coo);
1438 
1439   /****************************************************************************
1440   *                      LECTURE DES FAMILLES                                 *
1441   ****************************************************************************/
1442   lecture_famille_maillage(fid,nommaa,nfam);
1443 
1444 
1445   /****************************************************************************
1446   *                       LECTURE DES EQUIVALENCES                            *
1447   ****************************************************************************/
1448   lecture_equivalence_maillage(fid,nommaa,nequ);
1449 
1450 
1451   /****************************************************************************
1452   *                       LECTURE DES JOINTS                                  *
1453   ****************************************************************************/
1454   lecture_joint_maillage(fid,nommaa,njnt);
1455 
1456   return;
1457 }
1458 
1459 
1460 void lecture_caracteristiques_grille(med_idt fid,
1461                                      char *nommaa,
1462                                      med_int mdim,
1463                                      med_int *nind,
1464                                      med_int *nnoe,
1465                                      med_int *nmai,
1466                                      med_type_grille *type)
1467 {
1468   med_err ret = 0;
1469   med_int axe;
1470   med_int *structure_grille;
1471   med_table quoi;
1472   med_int j;
1473 
1474   /* lecture de la nature du maillage structure : MED_GRILLE_CARTESIENNE ,
1475      ...*/
1476   ret = MEDnatureGrilleLire(fid,nommaa,type);
1477   EXIT_IF(ret < 0,"a la lecture du type d'une grille ",NULL);
1478 
1479   switch(*type) {
1480 
1481   case MED_GRILLE_CARTESIENNE :
1482   case MED_GRILLE_POLAIRE :
1483     if (*type == MED_GRILLE_CARTESIENNE)
1484       fprintf(stdout,"- Type de grille : MED_GRILLE_CARTESIENNE \n");
1485     else
1486       fprintf(stdout,"- Type de grille : MED_GRILLE_POLAIRE \n");
1487     for (axe=1;axe<=mdim;axe++) {
1488       switch(axe) {
1489 
1490       case 1:
1491         quoi = MED_COOR_IND1;
1492         break;
1493 
1494       case 2:
1495         quoi = MED_COOR_IND2;
1496         break;
1497 
1498       case 3:
1499         quoi = MED_COOR_IND3;
1500         break;
1501       }
1502       nind[axe - 1] = MEDnEntMaa(fid,nommaa,quoi,MED_NOEUD,(med_geometrie_element)0,(med_connectivite)0);
1503       EXIT_IF(nind[axe - 1] < 0,
1504               "lors de la lecture de la taille d'un indice d'une grille",
1505               NULL);
1506       *nnoe = nind[axe - 1] * (*nnoe);
1507       *nmai = (nind[axe - 1] - 1) * (*nmai);
1508       fprintf(stdout,
1509               "- Taille de l'indice de l'axe %d des coordonnees : %d \n",
1510               axe,nind[axe - 1]);
1511     }
1512     break;
1513 
1514   case MED_GRILLE_STANDARD:
1515     fprintf(stdout,"- Type de grille : MED_GRILLE_DESTRUCTUREE \n");
1516     *nnoe = MEDnEntMaa(fid,nommaa,MED_COOR,MED_NOEUD,(med_geometrie_element)0,(med_connectivite)0);
1517     EXIT_IF(*nnoe < 0,"lors de la lecture du nombre de noeuds du maillage "
1518             ,nommaa);
1519 
1520     /* on alloue la memoire */
1521     structure_grille = (med_int *) malloc(sizeof(med_int)*mdim);
1522     EXIT_IF(structure_grille == NULL,NULL,NULL);
1523     /* on lit la structure de la grille
1524        et on affiche le resultat */
1525     ret = MEDstructureCoordLire(fid,nommaa,mdim,structure_grille);
1526     EXIT_IF(ret < 0,"lors de la lecture de la structure de la grille",
1527             NULL);
1528     fprintf(stdout,"- Structure de la grille : [ ");
1529     for (j=0;j<mdim;j++) {
1530       *nmai = (*(structure_grille+j) - 1) * (*nmai);
1531       fprintf(stdout," %d ",*(structure_grille+j));
1532     }
1533     fprintf(stdout," ] \n");
1534     /* on nettoie la memoire */
1535     free(structure_grille);
1536     break;
1537   }
1538 
1539   fprintf(stdout,"- Nombre de noeuds : %d \n",*nnoe);
1540   fprintf(stdout,"- Nombre de mailles : %d \n",*nmai);
1541 
1542   return;
1543 }
1544 
1545 void lecture_noeuds_maillage_structure(med_idt fid, char *nommaa,
1546                                        med_int mdim,med_int *nind,med_int nnoe,
1547                                        med_type_grille type,
1548                                        const med_mode_switch mode_coo)
1549 {
1550   med_err ret = 0;
1551   med_int axe,i,j;
1552   char comp_ind[MED_TAILLE_PNOM+1];
1553   char unit_ind[MED_TAILLE_PNOM+1];
1554   char comp[3*MED_TAILLE_PNOM+1];
1555   char unit[3*MED_TAILLE_PNOM+1];
1556   char str[MED_TAILLE_PNOM+1];
1557   med_float *coo = NULL;
1558   med_float *indices = NULL;
1559   med_table quoi;
1560   med_repere repere;
1561   med_int *nufano = NULL;
1562   med_int *numnoe = NULL;
1563   char *nomnoe = NULL;
1564 
1565   fprintf(stdout,"\n(*************************)\n");
1566   fprintf(stdout,"(* NOEUDS DE LA GRILLE : *)\n");
1567   fprintf(stdout,"(*************************)\n");
1568 
1569   switch(type) {
1570 
1571   case MED_GRILLE_CARTESIENNE :
1572   case MED_GRILLE_POLAIRE :
1573     /* on affiche les coordonnees de chacun des axes */
1574     for (axe = 1; axe<=mdim; axe++) {
1575       /* on alloue la memoire */
1576       indices = (med_float *) malloc(sizeof(med_float)*nind[axe - 1]);
1577       EXIT_IF(indices == NULL,NULL,NULL);
1578       /* on lit le tableau des indices de coordonnees
1579          et on affiche le resultat */
1580       ret = MEDindicesCoordLire(fid,nommaa,mdim,indices,nind[axe - 1],
1581                                 axe,comp_ind,unit_ind);
1582       EXIT_IF(ret < 0,"lors de la lecture d'un tableau d'indice",
1583               NULL);
1584       fprintf(stdout,"\n - Axe %s [%s] : [ ",comp_ind,unit_ind);
1585       for (j=0;j<nind[axe - 1];j++)
1586         fprintf(stdout," %f ",*(indices+j));
1587       printf(" ] \n");
1588       /* on nettoie la memoire */
1589       free(indices);
1590     }
1591     break;
1592 
1593   case MED_GRILLE_STANDARD:
1594     /* on alloue la memoire */
1595     coo = (med_float *) malloc(sizeof(med_float)*nnoe*mdim);
1596     EXIT_IF(coo == NULL,NULL,NULL);
1597     /* on va lire les coordonnees des noeuds */
1598     ret = MEDcoordLire(fid,nommaa,mdim,coo,MED_FULL_INTERLACE,MED_ALL,NULL,0,
1599                              &repere,comp,unit);
1600     EXIT_IF(ret < 0,"lors de la lecture des noeuds du maillage",NULL);
1601     /* on affiche le resultat */
1602     fprintf(stdout,"- Nom des coordonnees : \n");
1603     for (i=0;i<mdim;i++) {
1604       strncpy(str,comp+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
1605       str[MED_TAILLE_PNOM] = '\0';
1606       fprintf(stdout," %s ",str);
1607     }
1608     fprintf(stdout,"\n- Unites des coordonnees : \n");
1609     for (i=0;i<mdim;i++) {
1610       strncpy(str,unit+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
1611       str[MED_TAILLE_PNOM] = '\0';
1612       fprintf(stdout," %s ",str);
1613     }
1614     if (!structure) {
1615     fprintf(stdout,"\n - Coordonnees des noeuds : [ ");
1616     for (j=0;j<nnoe*mdim;j++)
1617       fprintf(stdout," %f ",*(coo+j));
1618     fprintf(stdout," ] \n");
1619     }
1620 
1621     /* on nettoie la memoire */
1622     free(coo);
1623     break;
1624   }
1625 
1626   /* lecture et affichage des :
1627      - numeros de familles des noeuds
1628      - noms des noeuds (optionnel)
1629      - numeros des noeuds (optionnel) */
1630 
1631   /* on alloue la memoire */
1632   numnoe = (med_int *) malloc(sizeof(med_int)*nnoe);
1633   EXIT_IF(numnoe == NULL,NULL,NULL);
1634   nomnoe = (char*) malloc(MED_TAILLE_PNOM*nnoe+1);
1635   EXIT_IF(nomnoe == NULL,NULL,NULL);
1636   nufano = (med_int *) malloc(sizeof(med_int)*nnoe);
1637   EXIT_IF(nufano == NULL,NULL,NULL);
1638 
1639   /* on va lire les numeros de familles des noeuds */
1640   ret = MEDfamLire(fid,nommaa,nufano,nnoe,MED_NOEUD,(med_geometrie_element)0);
1641   EXIT_IF(ret < 0,"lors de la lecture des numeros de familles des noeuds",
1642           NULL);
1643   if (!structure) {
1644   /* on affiche le resultat */
1645   fprintf(stdout,"\n- Numeros des familles des noeuds : \n");
1646   for (i=0;i<nnoe;i++)
1647     fprintf(stdout," %d ",*(nufano+i));
1648   fprintf(stdout,"\n");
1649   }
1650 
1651   /* on va lire et afficher les noms des noeuds */
1652   if (MEDnomLire(fid,nommaa,nomnoe,nnoe,MED_NOEUD,MED_POINT1) == 0) {
1653     if (!structure) {
1654     fprintf(stdout,"\n- Noms des noeuds : \n");
1655     for (i=0;i<nnoe;i++) {
1656       strncpy(str,nomnoe+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
1657       str[MED_TAILLE_PNOM] = '\0';
1658       fprintf(stdout," %s ",str);
1659     }
1660     }
1661   }
1662 
1663   /* on va lire et afficher les numeros des noeuds */
1664   if (MEDnumLire(fid,nommaa,numnoe,nnoe,MED_NOEUD,MED_POINT1) == 0) {
1665     if (!structure) {
1666     fprintf(stdout,"\n- Numeros des noeuds : \n");
1667     for (i=0;i<nnoe;i++)
1668       fprintf(stdout," %d ",*(numnoe+i));
1669     }
1670   }
1671 
1672   /* on nettoie la memoire */
1673   free(nufano);
1674   free(numnoe);
1675   free(nomnoe);
1676 
1677   return;
1678 }
1679 
1680 
1681 void lecture_mailles_maillage_structure(med_idt fid, char *nommaa,
1682                                         const med_int mdim,const med_int nmai)
1683 {
1684   med_err ret = 0;
1685   med_int i;
1686   med_int *nufael = NULL;
1687   char *nomele = NULL;
1688   med_int *numele = NULL;
1689   char str[MED_TAILLE_PNOM+1];
1690   /* type geometrique des elements */
1691   med_geometrie_element typgeo;
1692 
1693   fprintf(stdout,"\n(***************************)\n");
1694   fprintf(stdout,"(* ELEMENTS DE LA GRILLE : *)\n");
1695   fprintf(stdout,"(***************************)\n");
1696 
1697   /* type des mailles */
1698   switch(mdim) {
1699   case 0 :
1700     typgeo = MED_POINT1;
1701     break;
1702   case 1 :
1703     typgeo = MED_SEG2;
1704     break;
1705   case 2 :
1706     typgeo = MED_QUAD4;
1707     break;
1708   default :
1709     typgeo = MED_HEXA8;
1710   }
1711 
1712   /* On va lire et afficher :
1713    * - Les numeros de familles
1714    * - Les noms (optionnel)
1715    * - Les numeros (optionnel)
1716    */
1717 
1718   /* on alloue la memoire */
1719   numele = (med_int *) malloc(sizeof(med_int)*nmai);
1720   EXIT_IF(numele == NULL,NULL,NULL);
1721   nomele = (char *) malloc(sizeof(char)*MED_TAILLE_PNOM*nmai+1);
1722   EXIT_IF(nomele == NULL,NULL,NULL);
1723   nufael = (med_int *) malloc(sizeof(med_int)*nmai);
1724   EXIT_IF(nufael == NULL,NULL,NULL);
1725 
1726   /* lecture des numeros de famille */
1727   ret = MEDfamLire(fid,nommaa,nufael,nmai,MED_MAILLE,typgeo);
1728   if (ret < 0)
1729     for (i=0;i<nmai;i++)
1730       *(nufael+i) = 0;
1731 
1732   if (!structure) {
1733   /* on affiche le resultat */
1734   fprintf(stdout,"\n- Numeros des familles des mailles : \n");
1735   for (i=0;i<nmai;i++)
1736     fprintf(stdout," %d ",*(nufael+i));
1737   fprintf(stdout,"\n");
1738   }
1739 
1740   /* on va lire et afficher les noms des mailles */
1741   if (MEDnomLire(fid,nommaa,nomele,nmai,MED_MAILLE,typgeo) == 0) {
1742     if (!structure) {
1743     fprintf(stdout,"\n  - Noms : \n");
1744     for (i=0;i<nmai;i++) {
1745           strncpy(str,nomele+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
1746           str[MED_TAILLE_PNOM] = '\0';
1747           fprintf(stdout," %s ",str);
1748         }
1749         }
1750   }
1751 
1752   /* on va lire et afficher les numeros des mailles */
1753   if (MEDnumLire(fid,nommaa,numele,nmai,MED_MAILLE,typgeo) == 0) {
1754     if (!structure) {
1755     fprintf(stdout,"\n  - Numeros :\n");
1756     for (i=0;i<nmai;i++)
1757       fprintf(stdout," %d ",*(numele+i));
1758     }
1759   }
1760 
1761   /* on libere la memoire */
1762   free(nufael);
1763   free(nomele);
1764   free(numele);
1765 
1766   return;
1767 }
1768 
1769 
1770 void lecture_maillage_structure(med_idt fid, char *nommaa,med_int mdim,
1771                                 const med_mode_switch mode_coo,
1772                                 const int lecture_en_tete_seulement)
1773 {
1774   med_err ret = 0;
1775   /* nombre de valeurs selon les axes du repere */
1776   med_int nind[3];
1777   med_int nnoe = 1;
1778   med_int nmai = 1;
1779   /* type de la grille */
1780   med_type_grille type;
1781   /* nombre de familles */
1782   med_int nfam;
1783   /* nombre d'equivalences */
1784   med_int nequ;
1785   /* nombre de joints */
1786   med_int njnt;
1787 
1788   /* lecture selon la nature de la grille des caracteristiques 
1789      du maillage :
1790      - nombre de noeuds
1791      - nombre de mailles
1792   */
1793   lecture_caracteristiques_grille(fid,nommaa,mdim,nind,&nnoe,&nmai,&type);
1794 
1795   /* nombre de familles */
1796   nfam = lecture_nombre_famille(fid,nommaa);
1797 
1798   /* nombre d'equivalences  */
1799   nequ = lecture_nombre_equivalence(fid,nommaa);
1800 
1801   /* combien de joints */
1802   njnt = lecture_nombre_joint(fid,nommaa);
1803 
1804   if (lecture_en_tete_seulement)
1805     return ;
1806 
1807   /****************************************************************************
1808   *                      LECTURE DES NOEUDS                                   *
1809   ****************************************************************************/
1810   lecture_noeuds_maillage_structure(fid,nommaa,mdim,nind,nnoe,type,mode_coo);
1811 
1812   /****************************************************************************
1813   *                      LECTURE DES ELEMENTS                                 *
1814   ****************************************************************************/
1815   lecture_mailles_maillage_structure(fid,nommaa,mdim,nmai);
1816 
1817   /****************************************************************************
1818   *                      LECTURE DES FAMILLES                                 *
1819   ****************************************************************************/
1820   lecture_famille_maillage(fid,nommaa,nfam);
1821 
1822   /****************************************************************************
1823   *                       LECTURE DES EQUIVALENCES                            *
1824   ****************************************************************************/
1825   lecture_equivalence_maillage(fid,nommaa,nequ);
1826 
1827   /****************************************************************************
1828   *                       LECTURE DES JOINTS                                  *
1829   ****************************************************************************/
1830   lecture_joint_maillage(fid,nommaa,njnt);
1831 
1832   return ;
1833 }
1834 
1835 
1836 
1837 med_err getFieldsOn(med_idt fid, char* maillage,
1838                     char * nomcha, med_type_champ typcha, med_int ncomp,
1839                     med_entite_maillage entite, med_mode_switch stockage) {
1840 
1841   int j,k,l,m,n,nb_geo;
1842   med_int nbpdtnor=0,pflsize,*pflval,ngauss=0,ngroup,*vale=NULL,nval;
1843   med_int numdt=0,numo=0,lnsize,nbrefmaa;
1844   med_float *valr=NULL,dt=0.0;
1845   med_err ret=0;
1846   med_booleen local;
1847   char pflname [MED_TAILLE_NOM+1]="";
1848   char locname [MED_TAILLE_NOM+1]="";
1849   char * lien = NULL;
1850   char maa_ass [MED_TAILLE_NOM+1]="";
1851   char dt_unit [MED_TAILLE_PNOM+1]="";
1852   med_geometrie_element * type_geo;
1853   med_geometrie_element typ_noeud[1] = { MED_NONE };
1854   med_geometrie_element typmai[MED_NBR_GEOMETRIE_MAILLE+2] = {MED_POINT1,
1855                                                               MED_SEG2,
1856                                                               MED_SEG3,
1857                                                               MED_TRIA3,
1858                                                               MED_QUAD4,
1859                                                               MED_TRIA6,
1860                                                               MED_QUAD8,
1861                                                               MED_TETRA4,
1862                                                               MED_PYRA5,
1863                                                               MED_PENTA6,
1864                                                               MED_HEXA8,
1865                                                               MED_TETRA10,
1866                                                               MED_PYRA13,
1867                                                               MED_PENTA15,
1868                                                               MED_HEXA20,
1869                                                               MED_POLYGONE,
1870                                                               MED_POLYEDRE};
1871   med_geometrie_element typfac[MED_NBR_GEOMETRIE_FACE+1] = {MED_TRIA3,
1872                                                             MED_TRIA6,
1873                                                             MED_QUAD4,
1874                                                             MED_QUAD8,
1875                                                             MED_POLYGONE};
1876   med_geometrie_element typare[MED_NBR_GEOMETRIE_ARETE] = {MED_SEG2,MED_SEG3};
1877 
1878   char ** AFF;
1879 
1880   switch (entite) {
1881   case MED_NOEUD :
1882     type_geo = typ_noeud;
1883     nb_geo   = 1;
1884     AFF      = MED_GEOMETRIE_NOEUD_AFF;
1885     break;
1886   case  MED_MAILLE :
1887   case  MED_NOEUD_MAILLE :
1888     type_geo = typmai;
1889     nb_geo   = MED_NBR_GEOMETRIE_MAILLE+2;
1890     AFF      = MED_GEOMETRIE_MAILLE_AFF;
1891     break;
1892   case  MED_FACE :
1893     type_geo = typfac;
1894     nb_geo   = MED_NBR_GEOMETRIE_FACE+1;
1895     AFF      = MED_GEOMETRIE_FACE_AFF;
1896     break;
1897   case  MED_ARETE :
1898     type_geo = typare;
1899     nb_geo   = MED_NBR_GEOMETRIE_ARETE;
1900     AFF      = MED_GEOMETRIE_ARETE_AFF;
1901    break;
1902   }
1903 
1904   for (k=0;k<nb_geo;k++) {
1905 
1906     /* Combien de (PDT,NOR) a lire */
1907     nbpdtnor = MEDnPasdetemps(fid,nomcha,entite,type_geo[k]);
1908     if (nbpdtnor < 1 ) continue;
1909 
1910     for (j=0;j<nbpdtnor;j++) {
1911 
1912       if ( MEDpasdetempsInfo(fid,nomcha,entite,type_geo[k],
1913                              j+1, &ngauss, &numdt, &numo, dt_unit,
1914                              &dt, maa_ass, &local, &nbrefmaa) <0) {
1915         MESSAGE("Erreur a la demande d'information sur (pdt,nor) : ");
1916         ISCRUTE(numdt); ISCRUTE(numo);
1917         ret = -1; continue;
1918       };
1919 
1920       printf("\n  +Pas de Temps n.%i (%f) [%s], n. d'ordre %i, avec %i pts de gauss sur le maillage par defaut.\n",numdt,dt,dt_unit,numo,ngauss);
1921 
1922       printf("\tLe maillage par defaut est : |%s|, sur un total de : %i maillages associes\n",
1923              maa_ass, nbrefmaa);
1924 
1925       /* Le maillage reference est-il porte par un autre fichier */
1926       if ( !local ) {
1927 
1928         if ( (lnsize=MEDnValLien(fid,maa_ass) ) < 0 )  {
1929           MESSAGE("Erreur a la lecture de la taille du lien : ");
1930           SSCRUTE(maa_ass);
1931           ret = -1;
1932         } else {
1933 
1934           lien = (char *)malloc(lnsize*sizeof(char) + 1);
1935           EXIT_IF(lien == NULL,NULL,NULL);
1936 
1937           if ( MEDlienLire(fid, lien, maa_ass) < 0 )  {
1938             MESSAGE("Erreur a la lecture du lien : ");
1939             SSCRUTE(maa_ass);SSCRUTE(lien);
1940             ret = -1;
1941           } else {
1942         lien[lnsize] = '\0';
1943             printf("\tLe maillage |%s| est porte par un fichier distant |%s|\n"
1944                    ,maa_ass,lien);
1945           }
1946           free(lien);
1947         }
1948       }
1949 
1950       /* Combien de maillages lies aux (nomcha,ent,geo,numdt,numo)  */
1951       /* Notons que cette information est egalement disponible a partir de MEDpasdetempsInfo */
1952       if ( (nbrefmaa = MEDnChampRef(fid,nomcha,entite,type_geo[k],numdt,numo) ) < 0 ) {
1953         MESSAGE("Erreur a la demande du nombre de maillages references par le champ : ");
1954         SSCRUTE(nomcha); ISCRUTE(numdt); ISCRUTE(numo);
1955         ret = -1; continue;
1956       };
1957 
1958       for (l=0;l<nbrefmaa;l++) {
1959 
1960         if ( MEDchampRefInfo(fid,nomcha,entite,type_geo[k],
1961                              l+1,numdt, numo, maa_ass, &local, &ngauss) <0 ) {
1962           MESSAGE("Erreur a la demande d'information sur le maillage utilise par le champ n° : ");
1963           ISCRUTE(l+1);
1964           ret = -1; continue;
1965         };
1966 
1967         /* Prend en compte le nbre de pt de gauss automatiquement */
1968         if ((nval = MEDnVal(fid,nomcha,entite,type_geo[k],numdt,numo,maa_ass,USER_MODE)) <= 0)   {
1969           MESSAGE("Erreur a la lecture du nombre de valeurs du champ : ");
1970           SSCRUTE(nomcha);ISCRUTE(entite);ISCRUTE(type_geo[k]);
1971           ISCRUTE(numdt);ISCRUTE(numo);SSCRUTE(maa_ass);ISCRUTE(USER_MODE);
1972           ret = -1; continue;
1973         };
1974 
1975         if (! strcmp(maa_ass,maillage)) {
1976           printf("\t- Il y a %d valeurs en mode %i. Chaque entite %s\
1977  de type geometrique %s associes au maillage |%s| a %i pts de gauss \n",
1978                nval,USER_MODE,MED_ENTITE_MAILLAGE_AFF[(int)entite],AFF[k],
1979                  maa_ass,ngauss);
1980 
1981           /* Le maillage reference est-il porte par un autre fichier */
1982           if ( !local ) {
1983 
1984             if ( (lnsize=MEDnValLien(fid,maa_ass) ) < 0 )  {
1985               MESSAGE("Erreur a la lecture de la taille du lien : ");
1986               SSCRUTE(maa_ass);
1987               ret = -1;
1988             } else {
1989               lien = (char *)malloc(lnsize*sizeof(char) + 1);
1990               EXIT_IF(lien == NULL,NULL,NULL);
1991 
1992               if ( MEDlienLire(fid, lien, maa_ass) < 0 )  {
1993                 MESSAGE("Erreur a la lecture du lien : ");
1994                 SSCRUTE(maa_ass);SSCRUTE(lien);
1995                 ret = -1;
1996               } else {
1997         lien[lnsize] = '\0';
1998                 printf("\tLe maillage |%s| est porte par un fichier distant |%s|\n",maa_ass,lien);
1999               }
2000             free(lien);
2001             }
2002           }
2003 
2004         /*Lecture des valeurs du champ */
2005         if (typcha == MED_FLOAT64) {
2006 
2007           valr = (med_float*) calloc(ncomp*nval,sizeof(med_float));
2008           EXIT_IF(valr == NULL,NULL,NULL);
2009           if ( MEDchampLire(fid,maa_ass,nomcha,(unsigned char*)valr,stockage,
2010                             MED_ALL,locname,
2011                             pflname,USER_MODE,entite,
2012                             type_geo[k],numdt,numo) < 0 ) {
2013             MESSAGE("Erreur a la lecture du nombre de valeurs du champ : ");
2014             SSCRUTE(nomcha);ISCRUTE(entite);ISCRUTE(type_geo[k]);
2015             ISCRUTE(numdt);ISCRUTE(numo);SSCRUTE(maa_ass);
2016             ret = -1;
2017           };
2018 
2019         } else {
2020 
2021           vale = (med_int*) calloc(ncomp*nval,sizeof(med_int));
2022           EXIT_IF(vale == NULL,NULL,NULL);
2023           if ( MEDchampLire(fid,maa_ass,nomcha,(unsigned char*)vale,stockage,MED_ALL,locname,
2024                             pflname,USER_MODE,entite,type_geo[k],numdt,numo) < 0 ) {
2025             MESSAGE("Erreur a la lecture des valeurs du champ : ");
2026             SSCRUTE(nomcha);ISCRUTE(entite);ISCRUTE(type_geo[k]);
2027             ISCRUTE(numdt);ISCRUTE(numo);SSCRUTE(maa_ass);
2028             ret = -1;
2029           };
2030 
2031         }
2032 
2033     if (entite == MED_NOEUD_MAILLE )
2034       ngroup = type_geo[k] % 100;
2035     else
2036       ngroup = ngauss;
2037 
2038       switch (stockage) {
2039 
2040       case MED_FULL_INTERLACE :
2041       if (!structure) {
2042           printf("\t- Valeurs :\n\t");
2043           for (m=0;m<nval/ngroup;m++) {
2044             printf("|");
2045             for (n=0;n<ngroup*ncomp;n++)
2046               if (typcha == MED_FLOAT64)
2047                 printf(" %f ",*(valr+(m*ngroup*ncomp)+n));
2048               else
2049                 printf(" %d ",*(vale+(m*ngroup*ncomp)+n));
2050 
2051           }
2052           }
2053         break;
2054 
2055       case MED_NO_INTERLACE :
2056       if (!structure) {
2057           printf("\t- Valeurs :\n\t");
2058           for (m=0;m<ncomp;m++) {
2059             printf("|");
2060             for (n=0;n<nval;n++)
2061               if (typcha == MED_FLOAT64)
2062                 printf(" %f ",*(valr+(m*nval)+n));
2063               else
2064                 printf(" %d ",*(vale+(m*nval)+n));
2065           }
2066           }
2067         break;
2068       }
2069 
2070     if (!structure) {
2071         printf("|\n");
2072         }
2073       if (typcha == MED_FLOAT64) {
2074         if ( valr ) {free(valr);valr = NULL;}}
2075       else
2076         if (vale) { free(vale);vale = NULL; }
2077 
2078       /*Lecture du profil associe */
2079         if (strcmp(pflname,MED_NOPFL) == 0 )
2080           printf("\t- Profil : MED_NOPFL\n");
2081         else {
2082 
2083           if ( (pflsize = MEDnValProfil(fid,pflname)) <0 )  {
2084             MESSAGE("Erreur a la lecture du nombre de valeurs du profil : ");
2085             SSCRUTE(pflname);
2086             ret = -1; continue;
2087           }
2088 
2089           printf("\t- Profil : |%s| de taille %i\n",pflname,pflsize);
2090 
2091           pflval = (med_int*) malloc(sizeof(med_int)*pflsize);
2092           EXIT_IF(pflval == NULL,NULL,NULL);
2093           if ( MEDprofilLire(fid,pflval,pflname) <0) {
2094             MESSAGE("Erreur a la lecture des valeurs du profil : ");
2095             SSCRUTE(pflname);
2096             ret = -1;
2097           }
2098       if (!structure) {
2099           printf("\t");
2100           for (m=0;m<pflsize;m++) printf(" %i ",*(pflval+m));
2101           printf("\n");
2102           }
2103           free(pflval);
2104 
2105         }
2106         }
2107 
2108       }
2109     }
2110   } /* fin for sur les mailles*/
2111 
2112   return ret;
2113 }
2114 
2115 /******************************************************************************
2116  * 
2117  * - Nom de la fonction : lecture_resultats
2118  * - Description : lecture et affichage des champs de resultats
2119  *                 associe a un  maillage MED.
2120  * - Parametres :
2121  *     - fid                       (IN) : ID du fichier MED.
2122  *     - maillage                  (IN) : nom du maillage maillage.
2123  *     - mode_coo                  (IN) : mode de stockage en memoire :
2124  *                                        MED_FULL_INTERLACE |
2125  *                                        MED_NO_INTERLACE.
2126  *     - lecture_en_tete_seulement (IN) : mode de lecture.
2127  ******************************************************************************/
2128 
2129 void lecture_resultats(med_idt fid,
2130                        char * maillage,
2131                        med_mode_switch mode_coo,
2132                        int lecture_en_tete_seulement)
2133 {
2134   med_err ret,lret;
2135   char pflname[MED_TAILLE_NOM+1]="",nomlien[MED_TAILLE_NOM+1]="";
2136   char * lien = NULL;
2137   char *comp, *unit;
2138   char nomcha  [MED_TAILLE_NOM+1]="";
2139   char locname[MED_TAILLE_NOM+1]="";
2140   med_int mdim,ncomp,ncha,npro,nln,pflsize,*pflval,nval,nloc,ngauss;
2141   med_type_champ typcha;
2142   med_maillage type;
2143   int t1,t2,t3;
2144   med_geometrie_element type_geo;
2145   med_float *refcoo, *gscoo, *wg;
2146   int i,j;
2147 
2148   if (! lecture_en_tete_seulement) {
2149     fprintf(stdout,"\n(************************)\n");
2150     fprintf(stdout,"(* CHAMPS DU MAILLAGE : *)\n");
2151     fprintf(stdout,"(************************)\n");
2152   }
2153 
2154   /* combien de champs dans le fichier */
2155   ncha = MEDnChamp(fid,0);
2156   EXIT_IF(ncha < 0,"lors de la lecture du nombre de champs",NULL);
2157   fprintf(stdout,"- Nombre de champs : %d \n",ncha);
2158 
2159   if (lecture_en_tete_seulement)
2160     return;
2161 
2162   /****************************************************************************
2163   *                       LECTURE DES CHAMPS                                  *
2164   ****************************************************************************/
2165   ret = 0;
2166 
2167   /* lecture de tous les champs  pour le maillage selectionne */
2168   for (i =0;i<ncha;i++) {
2169     lret = 0;
2170     printf("\nChamp numero : |%d| \n",i+1);
2171 
2172     /* Lecture du nombre de composantes */
2173     if ((ncomp = MEDnChamp(fid,i+1)) < 0) {
2174       MESSAGE("Erreur à la lecture du nombre de composantes : ");
2175       ISCRUTE(ncomp);
2176       ret = -1; continue;
2177     }
2178 
2179     /* Lecture du type du champ, des noms des composantes et du nom de
2180        l'unité*/
2181     comp = (char*) malloc(ncomp*MED_TAILLE_PNOM+1);
2182     EXIT_IF(comp == NULL,NULL,NULL);
2183     unit = (char*) malloc(ncomp*MED_TAILLE_PNOM+1);
2184     EXIT_IF(unit == NULL,NULL,NULL);
2185 
2186     if ( MEDchampInfo(fid,i+1,nomcha,&typcha,comp,unit,ncomp) < 0 ) {
2187       MESSAGE("Erreur à la demande d'information sur les champs : ");
2188       ret = -1; continue;
2189     }
2190 
2191     printf("Nom du champ : |%s| de type |%d|\n",nomcha,typcha);
2192     printf("Nom des composantes : |%s|\n",comp);
2193     printf("Unites des composantes : |%s| \n",unit);
2194 
2195     free(comp);
2196     free(unit);
2197 
2198     /* champs aux noeuds */
2199     lret = getFieldsOn(fid, maillage, nomcha, typcha, ncomp, MED_NOEUD,mode_coo);
2200 
2201     /* champs sur les elements et aux points de Gauss */
2202     if (lret == 0) lret = getFieldsOn(fid, maillage, nomcha, typcha, ncomp, MED_MAILLE,mode_coo);
2203     else { MESSAGE("Erreur à la lecture des champs aux noeuds "); ret = -1; continue;}
2204 
2205     if (lret == 0) lret = getFieldsOn(fid, maillage, nomcha, typcha, ncomp, MED_FACE,mode_coo);
2206     else { MESSAGE("Erreur à la lecture des champs aux mailles "); ret = -1; continue;}
2207 
2208     if (lret == 0) lret = getFieldsOn(fid, maillage, nomcha, typcha, ncomp, MED_ARETE,mode_coo);
2209     else {MESSAGE("Erreur à la lecture des champs aux faces "); ret = -1; continue;}
2210 
2211     if (lret == 0) lret = getFieldsOn(fid, maillage, nomcha, typcha, ncomp, MED_NOEUD_MAILLE,mode_coo);
2212     else {MESSAGE("Erreur a la lecture des champs aux aretes "); ret = -1; continue;}
2213 
2214     if  (lret != 0) {MESSAGE("Erreur a la lecture des champs aux noeuds des mailles "); ret = -1;};
2215   }
2216 
2217 
2218   /* Interrogation des profils */
2219   npro = MEDnProfil(fid);
2220 
2221   printf("\nNombre de profils stockes : %i\n\n",npro);
2222   for (i=1 ; i <= npro ; i++ ) {
2223     if ( MEDprofilInfo(fid, i, pflname, &nval) < 0)  {
2224       MESSAGE("Erreur a la demande d'information sur le profil n° : "); ISCRUTE(i);
2225       ret = -1;continue;
2226     }
2227     printf("\t- Profil n°%i de nom |%s| et de taille %i\n",i,pflname,nval);
2228     pflval = (med_int*) malloc(sizeof(med_int)*nval);
2229     if ( MEDprofilLire(fid, pflval, pflname) < 0) {
2230       MESSAGE("Erreur a la lecture des valeurs du profil : ");
2231       SSCRUTE(pflname);
2232       ret = -1;
2233     } else {
2234       if (!structure) {
2235       printf("\t");
2236       for (j=0;j<nval;j++) printf(" %i ",*(pflval+j));
2237       printf("\n\n");
2238       }
2239     }
2240     free(pflval);
2241   }
2242 
2243   /* Interrogation des liens */
2244   nln = MEDnLien(fid);
2245 
2246   printf("\nNombre de liens stockes : %i\n\n",nln);
2247   for (i=1 ; i <= nln ; i++ ) {
2248     if ( MEDlienInfo(fid, i, nomlien, &nval) < 0)  {
2249       MESSAGE("Erreur a la demande d'information sur le lien n° : "); ISCRUTE(i);
2250       ret = -1;continue;
2251     }
2252     printf("\t- Lien n°%i de nom |%s| et de taille %i\n",i,nomlien,nval);
2253 
2254     lien = (char *)malloc(nval*sizeof(char) + 1);
2255     EXIT_IF(lien == NULL,NULL,NULL);
2256 
2257     if ( MEDlienLire(fid, lien, nomlien) < 0 )  {
2258       MESSAGE("Erreur a la lecture du lien : ");
2259       SSCRUTE(nomlien);SSCRUTE(lien);
2260       ret = -1;
2261     } else {
2262       lien[nval] = '\0';
2263       printf("\t\t|%s|\n\n",lien);
2264     }
2265     free(lien);
2266   }
2267 
2268   /* Interrogation des localisations des points de GAUSS */
2269   nloc = MEDnGauss(fid);
2270 
2271   printf("\nNombre de localisations stockees : %i\n\n",nloc);
2272   for (i=1 ; i <= nloc ; i++ ) {
2273     if ( MEDgaussInfo(fid, i, locname, &type_geo, &ngauss) < 0)  {
2274       MESSAGE("Erreur a la demande d'information sur la localisation n° : "); ISCRUTE(i);
2275       ret = -1;continue;
2276     }
2277     printf("\t- Loc. n°%i de nom |%s| et nbr. de pts de GAUSS %i\n",i,locname,ngauss);
2278     t1 = (type_geo%100)*(type_geo/100);
2279     t2 = ngauss*(type_geo/100);
2280     t3 = ngauss;
2281     refcoo = (med_float *) malloc(sizeof(med_float)*t1 );
2282     gscoo  = (med_float *) malloc(sizeof(med_float)*t2 );
2283     wg     = (med_float *) malloc(sizeof(med_float)*t3 );
2284 
2285     if ( MEDgaussLire(fid, refcoo, gscoo, wg, mode_coo, locname ) < 0) {
2286       MESSAGE("Erreur a la lecture des valeurs de la localisation : ");
2287       SSCRUTE(locname);
2288       ret = -1;
2289     } else {
2290       if (!structure) {
2291       printf("\t  Coordonnees de l'element de reference de type %i :\n\t\t",type_geo);
2292       for (j=0;j<t1;j++) printf(" %f ",*(refcoo+j));
2293       printf("\n");
2294       printf("\t  Localisation des points de GAUSS : \n\t\t");
2295       for (j=0;j<t2;j++) printf(" %f ",*(gscoo+j));
2296       printf("\n");
2297       printf("\t  Poids associes aux points de GAUSS :\n\t\t");
2298       for (j=0;j<t3;j++) printf(" %f ",*(wg+j));
2299       printf("\n\n");
2300       }
2301     }
2302     free(refcoo);
2303     free(gscoo);
2304     free(wg);
2305   }
2306 
2307   return;
2308 }
2309 
2310 /******************************************************************************
2311  *
2312  * - Nom de la fonction : lecture_parametres_scalaires
2313  * - Description : lecture des parametres scalaires definis
2314  *                 hors champs et maillages.
2315  * - Parametres :
2316  *     - fid                    (IN) : ID du fichier MED.
2317  *     - lecture_en_tete_seule  (IN) : mode de lecture.
2318  *
2319  ******************************************************************************/
2320 
2321 void lecture_parametres_scalaires(med_idt fid,
2322                                   int lecture_en_tete_seulement)
2323 {
2324   med_err ret = 0;
2325   char nom_scalaire[MED_TAILLE_NOM+1];
2326   char description[MED_TAILLE_DESC+1];
2327   med_int vali;
2328   med_float valr;
2329   med_int i,n,npdt,j;
2330   med_type_champ type;
2331   med_int numdt,numo;
2332   med_float dt;
2333   char dt_unit[MED_TAILLE_PNOM+1];
2334 
2335   fprintf(stdout,"\n(*******************************)\n");
2336   fprintf(stdout,"(* VARIABLES SCALAIRES       : *)\n");
2337   fprintf(stdout,"(*******************************)\n");
2338 
2339   /* Combien de variables scalaire ? */
2340   n = MEDnScalaire(fid);
2341   EXIT_IF(n < 0,"lors de la lecture du nombre de scalaires",NULL);
2342   fprintf(stdout,"- Nombre de variables scalaires : %d\n",n);
2343 
2344   if (lecture_en_tete_seulement)
2345     return ;
2346 
2347   for (i=1;i<=n;i++) {
2348 
2349     /* Lecture des infos (type,description) */
2350     ret = MEDscalaireInfo(fid,i,nom_scalaire,&type,description);
2351     EXIT_IF(ret < 0,"lors de la lecture des parametres d'un scalaire",NULL);
2352     fprintf(stdout,"- Scalaire n°%d de nom %s \n",i,nom_scalaire);
2353     if (type == MED_FLOAT64)
2354       fprintf(stdout,"  Type flottant. \n");
2355     else
2356       fprintf(stdout,"  Type entier. \n");
2357     printf("  Description associee : [%s] \n",description);
2358 
2359     /* Pour chaque scalaire on regarde les valeurs associees
2360        eventuellement a des pas de temps et des numeros d'ordre */
2361     npdt = MEDnScalairePasdetemps(fid,nom_scalaire);
2362     EXIT_IF(npdt < 0,
2363             "lors de la lecture du nombre de pas de temps d'un scalaire"
2364             ,NULL);
2365     fprintf(stdout,"   Nombre de valeurs stockees : %d \n",npdt);
2366 
2367     for (j=1;j<=npdt;j++) {
2368       ret = MEDscalairePasdetempsInfo(fid,nom_scalaire,j,
2369                                       &numdt,dt_unit,&dt,&numo);
2370       EXIT_IF(ret < 0,
2371               "lors de la lecture des parametres d'un pas de temps d'un scalaire",
2372               NULL);
2373 
2374       if (numdt == MED_NOPDT)
2375         fprintf(stdout,"   - Aucun de pas de temps \n");
2376       else
2377         fprintf(stdout,
2378                 "   - Pas de de temps de numero %d de valeur %f [%s] \n",numdt,
2379                dt,dt_unit);
2380       if (numo == MED_NONOR)
2381         fprintf(stdout,"   - Aucun numero d'ordre \n");
2382       else
2383         fprintf(stdout,"   - Numero d'ordre : %d \n",numo);
2384 
2385       if (type == MED_FLOAT64) {
2386         ret = MEDscalaireFlottantLire(fid,nom_scalaire,&valr,numdt,numo);
2387         fprintf(stdout,"   - Valeur : %f \n",valr);
2388       }
2389       else {
2390         ret = MEDscalaireEntierLire(fid,nom_scalaire,&vali,numdt,numo);
2391         fprintf(stdout,"   - Valeur : %d \n",vali);
2392       }
2393       EXIT_IF(ret < 0,"lors de la lecture de la valeur d'un scalaire",NULL);
2394 
2395     }
2396   }
2397 
2398   return ;
2399 }
2400 
2401 
2402 med_idt ouverture_fichier_MED(char *fichier)
2403 {
2404   med_idt fid;
2405   med_err ret = 0;
2406   med_int majeur,mineur,release;
2407 
2408   /* on regarde si le fichier existe */
2409   ret = (int) access(fichier,F_OK);
2410   EXIT_IF(ret < 0,"Le fichier n'est pas accessible ou n'existe pas ",
2411           fichier);
2412 
2413   /* on regarde s'il s'agit d'un fichier au format HDF 5 */
2414   ret = MEDformatConforme(fichier);
2415   EXIT_IF(ret < 0,"Le fichier n'est pas au format HDF V5 ",
2416           fichier);
2417 
2418   /* Quelle version de MED est utilise par mdump ? */
2419   MEDversionDonner(&majeur,&mineur,&release);
2420   fprintf(stdout,
2421           "- Lecture du fichier à l'aide de la bibliotheque MED V%d.%d.%d \n",
2422           majeur,mineur,release);
2423 
2424   /* Ouverture du fichier MED en lecture seule */
2425   fid = MEDouvrir(fichier,MED_LECTURE);
2426   EXIT_IF( fid < 0,"Ouverture du du fichier ",fichier);
2427 
2428   MEDversionLire(fid, &majeur, &mineur, &release);
2429   EXIT_IF((majeur < 2 || majeur == 2 && mineur < 2), "Le fichier est antérieur à la version 2.2", NULL);
2430 
2431   return fid;
2432 }
2433 
2434 void lecture_en_tete(med_idt fid,char* fichier)
2435 {
2436   med_int long_fichier_en_tete;
2437   char *fichier_en_tete;
2438   med_err ret = 0;
2439 
2440   /* lecture de l'en-tete du fichier (optionnel) */
2441   long_fichier_en_tete = MEDlFichDes(fid);
2442   if (long_fichier_en_tete > 0) {
2443     fichier_en_tete = (char *) malloc(sizeof(char)*(long_fichier_en_tete+1));
2444     EXIT_IF(fichier_en_tete == NULL,NULL,NULL);
2445 
2446     /* on va lire dans le fichier */
2447     ret = MEDfichEntete(fid,MED_FICH_DES,fichier_en_tete);
2448     EXIT_IF(ret < 0,"lecture de l'en-tete du fichier",fichier);
2449 
2450     /* on affiche */
2451     fprintf(stdout,"- En-tete du fichier : %s \n",fichier_en_tete);
2452 
2453     /* on libere la memoire */
2454     free(fichier_en_tete);
2455   }
2456 
2457   return;
2458 }
2459 
2460 void parametrage(med_mode_switch *mode_coo,
2461                  med_connectivite *typ_con)
2462 {
2463   int reponse;
2464 
2465   fprintf(stdout,"(*****************)\n");
2466   fprintf(stdout,"(* PARAMETRAGE : *)\n");
2467   fprintf(stdout,"(*****************)\n");
2468   fprintf(stdout,"- Mode d'affichage des coordonnées des noeuds ? \n");
2469   fprintf(stdout,"  1. Mode entrelacé : taper 1 \n");
2470   fprintf(stdout,"  2. Mode non entrelacé : taper 2 \n");
2471   reponse = 0;
2472   do {
2473     fprintf(stdout,"  Reponse : ");
2474     scanf("%d",&reponse);
2475   } while (reponse != 1 && reponse != 2);
2476   if (reponse == 1)
2477     *mode_coo = MED_FULL_INTERLACE;
2478   else
2479     *mode_coo = MED_NO_INTERLACE;
2480 
2481   fprintf(stdout,"- Connectivité des éléments ? \n");
2482   fprintf(stdout,"  1. Nodale : taper 1 \n");
2483   fprintf(stdout,"  2. Descendante : taper 2 \n");
2484   reponse = 0;
2485   do {
2486     fprintf(stdout,"  Reponse : ");
2487     scanf("%d",&reponse);
2488   } while (reponse != 1 && reponse != 2);
2489   if (reponse == 1)
2490     *typ_con = MED_NOD;
2491   else
2492     *typ_con = MED_DESC;
2493 
2494   return;
2495 }
2496 
2497 
2498 void lecture_information_maillage(med_idt fid,
2499                                   int numero,
2500                                   char *nommaa,
2501                                   med_int *mdim,
2502                                   med_maillage *type_maillage,
2503                                   char *maillage_description)
2504 {
2505   med_int edim;
2506   char nom_universel[MED_TAILLE_LNOM+1];
2507   med_err ret = 0;
2508 
2509   fprintf(stdout,"\n(********************************************)\n");
2510   fprintf(stdout,"(* INFORMATIONS GENERALES SUR LE MAILLAGE : *)\n");
2511   fprintf(stdout,"(********************************************)\n");
2512 
2513   /* lecture du nom et de la dimension du maillage */
2514   ret = MEDmaaInfo(fid,numero,nommaa,mdim,type_maillage,maillage_description);
2515   EXIT_IF(ret < 0,"Lecture des informations sur le maillage",NULL);
2516 
2517   /* lecture de la dimension de l'espace de calcul */
2518   edim = MEDdimEspaceLire(fid,nommaa);
2519 
2520   /* affichage des donnees lues */
2521   fprintf(stdout,"- Nom du maillage : <<%s>>\n",nommaa);
2522   fprintf(stdout,"- Dimension du maillage : %d\n",*mdim);
2523   if (edim > *mdim)
2524     fprintf(stdout,"- La dimension de l'espace est %d \n",edim);
2525   if (*type_maillage == MED_NON_STRUCTURE)
2526     fprintf(stdout,"- Type du maillage : MED_NON_STRUCTURE \n");
2527   else
2528     fprintf(stdout,"- Type du maillage : MED_STRUCTURE \n");
2529   fprintf(stdout,"- Description associee au maillage : %s\n",
2530           maillage_description);
2531 
2532  /* lecture du nom universel (presence optionnelle) */
2533  ret = MEDunvLire(fid,nommaa,nom_universel);
2534  if (ret == 0)
2535    fprintf(stdout,"- Nom universel du maillage : %s \n",nom_universel);
2536 
2537  return;
2538 }
2539 
2540 /******************************************************************************
2541  *
2542  * - Nom de la fonction : main
2543  * - Description : fonction "main" de l'outil de DUMP d'un fichier MED.
2544  * - Parametres :
2545  *     - argc  (IN) : nombre d'arguments sur la ligne de commande.
2546  *     - argv  (IN) : liste des arguments.
2547  *
2548  ******************************************************************************/
2549 
2550 int main (int argc, char **argv)
2551 {
2552   med_err ret = 0;
2553   med_idt fid;
2554   int i;
2555   int numero;
2556   med_mode_switch mode_coo;
2557   med_connectivite typ_con;
2558   int lecture_en_tete_seulement = 0;
2559   char version_hdf[10];
2560   char version_med[10];
2561   med_int mdim,nmaa;
2562   /* nom du maillage */
2563   char nommaa[MED_TAILLE_NOM+1];
2564   char maillage_description[MED_TAILLE_DESC+1];
2565   med_maillage type_maillage;
2566   med_int edim;
2567   med_int majeur_lu,mineur_lu,release_lu;
2568   med_int nprofils;
2569   int decalage;
2570 
2571   /****************************************************************************
2572   *                  TEST DU NOMBRE D'ARGUMENTS                               *
2573   *                  argument 1 = nom du fichier MED                          *
2574   ****************************************************************************/
2575 
2576   structure = 0;
2577   decalage = 0;
2578   if (argc > 2 && strcmp(argv[1], "--structure") == 0) {
2579     argc--;
2580     decalage = 1;
2581     structure = 1;
2582   }
2583 
2584   EXIT_IF(argc != 2 && argc != 5,"nombre de parametres incorrects\n",NULL);
2585 
2586 
2587   /****************************************************************************
2588   *                      OUVERTURE DU FICHIER EN LECTURE                      *
2589   ****************************************************************************/
2590   fid = ouverture_fichier_MED(argv[1 + decalage]);
2591 
2592 
2593   /****************************************************************************
2594    *                     QUESTIONS PRELIMINAIRES                              *
2595    *    1. Mode d'affichage des coordonnees (entrelace ou non) ?              *
2596    *    2. Connectivite des elements (nodale ou descendante) ?                *
2597    ***************************************************************************/
2598   fprintf(stdout,"\n >>>>>> DUMP DU FICHIER %s >>>>>>\n",argv[1 + decalage]);
2599 
2600   /* lecture et affichage de l'en-tete du fichier */
2601   lecture_en_tete(fid,argv[1 + decalage]);
2602 
2603   if (argc == 2)
2604     parametrage(&mode_coo,&typ_con);
2605   else {
2606     if (! strcmp(argv[3 + decalage],"NODALE"))
2607       typ_con = MED_NOD;
2608     if (! strcmp(argv[3 + decalage],"DESCENDANTE"))
2609       typ_con = MED_DESC;
2610 
2611     if (!strcmp(argv[4 + decalage],"NO_INTERLACE"))
2612       mode_coo = MED_NO_INTERLACE;
2613     if (!strcmp(argv[4 + decalage],"FULL_INTERLACE"))
2614       mode_coo = MED_FULL_INTERLACE;
2615     if (! strcmp(argv[4 + decalage],"LECTURE_EN_TETE_SEULEMENT"))
2616       lecture_en_tete_seulement = 1;
2617   }
2618 
2619 
2620   /****************************************************************************
2621    *                      QUEL MAILLAGE LIRE ?                                *
2622    ***************************************************************************/
2623   nmaa = MEDnMaa(fid);
2624   EXIT_IF(nmaa < 0,"lors de la lecture du nombre de maillages",NULL);
2625 
2626   /* Quel maillage lire ? */
2627   if (argc == 2) {
2628     fprintf(stdout,"- Il y a %d maillages dans ce fichier \n",nmaa);
2629     fprintf(stdout,"  Lequel voulez-vous lire (1|2|3|...|n) ?\n");
2630     do {
2631       fprintf(stdout,"  Reponse : ");
2632       scanf("%d",&numero);
2633     } while (numero > nmaa || numero <= 0);
2634   }
2635   else {
2636     numero = atoi(argv[2 + decalage]);
2637     EXIT_IF(numero > nmaa || numero <= 0,"ce numero de maillage n'existe pas",
2638             NULL);
2639   }
2640 
2641   /****************************************************************************
2642    *                       PARAMETRES SCALAIRES                               *
2643    ****************************************************************************/
2644 
2645   /* on va lire l'ensemble des parametres scalaire */
2646   lecture_parametres_scalaires(fid,lecture_en_tete_seulement);
2647 
2648   /****************************************************************************
2649    *                       INFOS GENERALES SUR LE MAILLAGE                    *
2650    ****************************************************************************/
2651   lecture_information_maillage(fid,numero,nommaa,&mdim,&type_maillage,
2652                                maillage_description);
2653 
2654 
2655  /****************************************************************************
2656   *                      LECTURE DU MAILLAGE ET DES RESULTATS ASSOCIES        *
2657   ****************************************************************************/
2658  if (type_maillage == MED_NON_STRUCTURE)
2659    lecture_maillage_non_structure(fid,nommaa,mdim,mode_coo,typ_con,
2660                                   lecture_en_tete_seulement);
2661  else
2662    lecture_maillage_structure(fid,nommaa,mdim,mode_coo,
2663                               lecture_en_tete_seulement);
2664 
2665  /* on lit ensuite les resultats associes au maillage selectionne */
2666  lecture_resultats(fid,nommaa,mode_coo,lecture_en_tete_seulement);
2667 
2668  /****************************************************************************
2669  *                      FERMETURE DU FICHIER                                 *
2670  ****************************************************************************/
2671  ret = MEDfermer(fid);
2672  EXIT_IF(ret < 0,"lors de la fermeture du fichier",argv[1 + decalage]);
2673 
2674  fprintf(stdout,"\n >>>>>> FIN DU DUMP DU FICHIER %s >>>>>>\n",argv[1 + decalage]);
2675 
2676  return EXIT_SUCCESS;
2677 }