1  /****************************************************************************
   2  * COPYRIGHT (C) 1999 - 2003  EDF R&D
   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 V2.2
  23   *                 Ce fichier contient les fonctions suivantes
  24   *                 qui constituent des modeles de programmation
  25   *                 pour une lecture generique d'un fichier MED V2.2 :
  26   *                 - lecture_maillage_non_structure () :
  27   *                        1. Noeuds.
  28   *                        2. Mailles :
  29   *                           - APPORT V2.2 : polyedres et polygones.
  30   *                        3. Faces (connectivite descendante) :
  31   *                           - APPORT V2.2 : polygones.
  32   *                        4. Aretes (connectivite descendante).
  33   *                        5. Familles.
  34   *                        6. Equivalences.
  35   *                 - lecture_maillage_structure ()     : (APPORT V2.2)
  36   *                        1. Grille cartesienne | polaire | destructuree
  37   *                        2. Familles de noeuds. 
  38   *                 - lecture_resultats () :
  39   *                        1. Champs de resultats relatifs à un maillage.
  40   *                           - Entites :
  41   *                                - Noeuds
  42   *                                - Mailles
  43   *                                - Faces
  44   *                                - Aretes
  45   *                           - Gestion des pas de temps et numeros d'ordre :
  46   *                                - APPORT V2.2 : stockage des valeurs 
  47   *                                  associees a plusieurs maillages sous 
  48   *                                  un meme pas de temps.
  49   *                           - Gestion des profils.
  50   *                           - Gestion des liens vers des maillages distants
  51   *                                - APPORT V2.2.
  52   *                           - Gestion des points de Gauss :
  53   *                                - APPORT V2.2.: localisation des 
  54   *                                  points de Gauss.
  55   *                 - lecture_parametres_scalaires () : (APPORT V2.2)
  56   *                           - Valeurs scalaires entieres ou flottantes.
  57   *                           - Gestion des pas de temps et numeros d'ordre.
  58   *                 - main() : infos generales + lecture de tous les champs et 
  59   *                            du fichier MED passe en parametre.
  60   *
  61   *****************************************************************************/
  62
  63  #include <med.h>
  64  #include <med_utils.h>
  65  #include <stdio.h>
  66  #include <string.h>
  67  #include <stdlib.h>
  68
  69  #define USER_MODE MED_COMPACT
  70
  71  /******************************************************************************
  72   *
  73   * - Nom de la fonction : lecture_maillage_non_structure
  74   * - Description : lecture et affichage d'un maillage MED_NON_STRUCTURE.
  75   * - Parametres :
  76   *     - fid                       (IN) : ID du fichier MED.
  77   *     - nommaa                    (IN) : nom du maillage a lire.
  78   *     - mdim                      (IN) : dimension du maillage.
  79   *     - mode_coo                  (IN) : mode de stockage en memoire : 
  80   *                                        MED_FULL_INTERLACE | MED_NO_INTERLACE.
  81   *     - typ_con                   (IN) : mode de connectivite :
  82   *                                        MED_FULL_INTERLACE | MED_NO_INTERLACE.
  83   *     - lecture_en_tete_seulement (IN) : mode de lecture.
  84   *
  85   ******************************************************************************/
  86
  87  /* nombre de mailles concernees par les equivalences */
  88  #define NBR_MAILLE_EQU  7
  89
  90  void lecture_maillage_non_structure(med_idt fid,char *nommaa,med_int mdim,
  91                      med_mode_switch mode_coo,
  92                      med_connectivite typ_con,
  93                      int lecture_en_tete_seulement)
  94  {
  95    med_err ret = 0;
  96    int i,j,k,l;
  97    /* nombre d'objets MED */
  98    med_int nnoe;
  99    med_int nmai[MED_NBR_GEOMETRIE_MAILLE],nfac[MED_NBR_GEOMETRIE_FACE];
 100    med_int nare[MED_NBR_GEOMETRIE_ARETE];
 101    /* noeuds */
 102    med_float *coo;
 103    char nomcoo[3*MED_TAILLE_PNOM+1];
 104    char unicoo[3*MED_TAILLE_PNOM+1];
 105    char *nomnoe;
 106    med_int *numnoe;
 107    med_int *nufano;
 108    med_repere rep;
 109    med_booleen inonoe,inunoe;
 110    char str[MED_TAILLE_PNOM+1];
 111    /* elements */
 112    med_int edim;
 113    med_int taille;
 114    med_int *connectivite;
 115    char *nomele;
 116    med_int *numele;
 117    med_int *nufael;
 118    med_booleen inoele, inuele;
 119    med_geometrie_element typgeo;
 120    med_geometrie_element typmai[MED_NBR_GEOMETRIE_MAILLE] =
 121                                                    {MED_POINT1,MED_SEG2,
 122                             MED_SEG3,MED_TRIA3,
 123                             MED_TRIA6,MED_QUAD4,
 124                             MED_QUAD8,MED_TETRA4,
 125                             MED_TETRA10,MED_HEXA8,
 126                             MED_HEXA20,MED_PENTA6,
 127                             MED_PENTA15,MED_PYRA5,
 128                             MED_PYRA13};
 129    med_int desmai[MED_NBR_GEOMETRIE_MAILLE] = {0,2,3,3,3,4,4,4,4,6,6,5,5,5,5};
 130    med_int nmailles[MED_NBR_GEOMETRIE_MAILLE];
 131    char nommai[MED_NBR_GEOMETRIE_MAILLE] [MED_TAILLE_NOM+1] = {"MED_POINT1",
 132                                "MED_SEG2",
 133                                "MED_SEG3",
 134                                "MED_TRIA3",
 135                                "MED_TRIA6",
 136                                "MED_QUAD4",
 137                                "MED_QUAD8",
 138                                "MED_TETRA4",
 139                                "MED_TETRA10",
 140                                "MED_HEXA8",
 141                                "MED_HEXA20",
 142                                "MED_PENTA6",
 143                                "MED_PENTA15",
 144                                "MED_PYRA5",
 145                                "MED_PYRA13"};
 146    med_geometrie_element typfac[MED_NBR_GEOMETRIE_FACE] = {MED_TRIA3,MED_TRIA6,
 147                                MED_QUAD4,MED_QUAD8};
 148    med_int desfac[MED_NBR_GEOMETRIE_FACE] = {3,3,4,4};
 149    med_int nfaces[MED_NBR_GEOMETRIE_FACE];
 150    char nomfac[MED_NBR_GEOMETRIE_FACE][MED_TAILLE_NOM+1] = {"MED_TRIA3",
 151                                 "MED_TRIA6",
 152                                 "MED_QUAD4",
 153                                 "MED_QUAD8"};
 154    med_geometrie_element typare[MED_NBR_GEOMETRIE_ARETE] = {MED_SEG2,
 155                                 MED_SEG3};
 156    med_int desare[MED_NBR_GEOMETRIE_ARETE] = {2,3};
 157    med_int naretes[MED_NBR_GEOMETRIE_ARETE];
 158    char nomare[MED_NBR_GEOMETRIE_ARETE] [MED_TAILLE_NOM+1] = {"MED_SEG2",
 159                                   "MED_SEG3"};
 160    /* familles */
 161    med_int nfam;
 162    med_int natt,ngro;
 163    char *attdes,*gro;
 164    med_int *attval,*attide;
 165    char nomfam[MED_TAILLE_NOM+1];
 166    med_int numfam;
 167    char str1[MED_TAILLE_DESC+1];
 168    char str2[MED_TAILLE_LNOM+1];
 169    /* equivalences */
 170    med_int nequ,ncor;
 171    med_int *cor;
 172    char equ[MED_TAILLE_NOM+1];
 173    char des[MED_TAILLE_DESC+1];
 174    /* mailles/faces MED_POLYGONE et MED_POLYEDRE */
 175    med_int nmpolygones,nfpolygones,npolyedres;
 176    med_int *indexp, *indexf;
 177    int ind1,ind2,np,nf;
 178    char tmp[MED_TAILLE_NOM+1];
 179    med_err ret1,ret2,ret3;
 180    med_int nfa;
 181
 182    /* Combien de noeuds ? */
 183    nnoe = MEDnEntMaa(fid,nommaa,MED_COOR,MED_NOEUD,0,0);
 184    EXIT_IF(nnoe < 0,"lors de la lecture du nombre de noeuds",NULL);
 185    fprintf(stdout,"- Nombre de noeuds : %d \n",nnoe);
 186
 187    /* Combien de mailles, faces ou aretes ? */
 188    for (i=0;i<MED_NBR_GEOMETRIE_MAILLE;i++) {
 189      nmailles[i] = MEDnEntMaa(fid,nommaa,MED_CONN,MED_MAILLE,typmai[i],
 190                   typ_con);
 191      EXIT_IF(nmailles[i] < 0," lors de la lecture du nombre de mailles",NULL);
 192      fprintf (stdout,"- Nombre de mailles de type %s : %d \n",nommai[i],nmailles[i]);
 193    }
 194
 195    /* Combien de mailles polygones  ? */
 196    nmpolygones = MEDnEntMaa(fid,nommaa,MED_CONN,MED_MAILLE,MED_POLYGONE,
 197                 typ_con);
 198    EXIT_IF(nmpolygones < 0,"lors de la lecture du nombre de mailles polygone \n",
 199        NULL);
 200    fprintf(stdout,"- Nombre de mailles de type MED_POLYGONE : %d \n",nmpolygones);
 201
 202    /* Combien de mailles polyedres ? */
 203    npolyedres = MEDnEntMaa(fid,nommaa,MED_CONN,MED_MAILLE,MED_POLYEDRE,
 204                typ_con);
 205    EXIT_IF(npolyedres < 0,"lors de la lecture du nombre de mailles polyedre \n",
 206        NULL);
 207    fprintf(stdout,"- Nombre de mailles de type MED_POLYEDRE : %d \n",npolyedres);
 208
 209    /* Combien de faces ? */
 210    for (i=0;i<MED_NBR_GEOMETRIE_FACE;i++) {
 211      nfaces[i] = MEDnEntMaa(fid,nommaa,MED_CONN,MED_FACE,typfac[i],
 212                 typ_con);
 213      EXIT_IF(nfaces[i] < 0,"lors de la lecture du nombre de faces",NULL);
 214      fprintf (stdout,"- Nombre de faces de type %s : %d \n",nomfac[i],nfaces[i]);
 215    }
 216
 217    /* Combien de faces polygones  ? */
 218    nfpolygones = MEDnEntMaa(fid,nommaa,MED_CONN,MED_FACE,MED_POLYGONE,
 219                 typ_con);
 220    EXIT_IF(nfpolygones < 0,"lors de la lecture du nombre de faces polygone \n",
 221        NULL);
 222    fprintf(stdout,"- Nombre de faces de type MED_POLYGONE : %d \n",nfpolygones);
 223
 224    /* Combien d'aretes */
 225    for (i=0;i<MED_NBR_GEOMETRIE_ARETE;i++) {
 226      naretes[i] = MEDnEntMaa(fid,nommaa,MED_CONN,MED_ARETE,typare[i],
 227                  typ_con);
 228      EXIT_IF(naretes[i] < 0,"lors de la lecture du nombre d'aretes",NULL);
 229      fprintf (stdout,"- Nombre d'aretes de type %s : %d \n",nomare[i],naretes[i]);
 230    }
 231
 232    /* nombre de familles */
 233    nfam = MEDnFam(fid,nommaa);
 234    EXIT_IF(nfam < 0,"lors de la lecture du nombre de familles",NULL);
 235    fprintf(stdout,"- Nombre de familles : %d \n",nfam);
 236
 237    /* combien d'equivalences dans le fichier */
 238    nequ = MEDnEquiv(fid,nommaa);
 239    EXIT_IF(nequ < 0,"lors de la lecture du nombre d'equivalences",NULL);
 240    fprintf(stdout,"- Nombre d'equivalences : %d \n",nequ);
 241
 242    /* en fonction du mode de lecture, on continue ou non */
 243    if (lecture_en_tete_seulement)
 244      return;
 245
 246    /****************************************************************************
 247    *                       LECTURE DES NOEUDS                                  *
 248    ****************************************************************************/
 249
 250    /* Allocations memoires */
 251    /* table des coordonnees 
 252       profil : (dimension * nombre de noeuds ) */
 253    coo = (med_float*) malloc(sizeof(med_float)*nnoe*mdim);
 254    EXIT_IF(coo == NULL,NULL,NULL);
 255    /* table  des numeros, des numeros de familles des noeuds
 256       profil : (nombre de noeuds) */
 257    numnoe = (med_int*) malloc(sizeof(med_int)*nnoe);
 258    EXIT_IF(numnoe == NULL,NULL,NULL);
 259    nufano = (med_int*) malloc(sizeof(med_int)*nnoe);
 260    EXIT_IF(nufano == NULL,NULL,NULL);
 261    /* table des noms des noeuds 
 262       profil : (nnoe*MED_TAILLE_PNOM+1) */
 263    nomnoe = (char*) malloc(MED_TAILLE_PNOM*nnoe+1);
 264    EXIT_IF(nomnoe == NULL,NULL,NULL);
 265
 266    /* lecture des noeuds : 
 267       - coordonnees
 268       - noms (optionnel dans un fichier MED) 
 269       - numeros (optionnel dans un fichier MED) 
 270       - numeros des familles */
 271    ret = MEDnoeudsLire(fid,nommaa,mdim,coo,mode_coo,&rep,
 272                nomcoo,unicoo,nomnoe,&inonoe,numnoe,&inunoe,
 273                nufano,nnoe);
 274    EXIT_IF(ret < 0,"lors de la lecture des noeuds du maillage \n",NULL);
 275
 276    /* affichage des resultats */
 277    fprintf(stdout,"\n(************************)\n");
 278    fprintf(stdout,"(* NOEUDS DU MAILLAGE : *)\n");
 279    fprintf(stdout,"(************************)\n");
 280    fprintf(stdout,"- Type de repere des coordonnees : %d \n",rep);
 281    fprintf(stdout,"- Nom des coordonnees : \n");
 282    for (i=0;i<mdim;i++) {
 283      strncpy(str,nomcoo+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
 284      str[MED_TAILLE_PNOM] = '\0';
 285      fprintf(stdout," %s ",str);
 286    }
 287    fprintf(stdout,"\n- Unites des coordonnees : \n");
 288    for (i=0;i<mdim;i++) {
 289      strncpy(str,unicoo+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
 290      str[MED_TAILLE_PNOM] = '\0';
 291      fprintf(stdout," %s ",str);
 292    }
 293    fprintf(stdout,"\n- Coordonnees des noeuds : \n");
 294    for (i=0;i<nnoe*mdim;i++)
 295      fprintf(stdout," %f ",*(coo+i));
 296    if (inonoe) {
 297      fprintf(stdout,"\n- Noms des noeuds : \n");
 298      for (i=0;i<nnoe;i++) {
 299        strncpy(str,nomnoe+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
 300        str[MED_TAILLE_PNOM] = '\0';
 301        fprintf(stdout," %s ",str);
 302      }
 303    }
 304    if (inunoe) {
 305      fprintf(stdout,"\n- Numeros des noeuds : \n");
 306      for (i=0;i<nnoe;i++)
 307        fprintf(stdout," %d ",*(numnoe+i));
 308    }
 309    fprintf(stdout,"\n- Numeros des familles des noeuds : \n");
 310    for (i=0;i<nnoe;i++)
 311      fprintf(stdout," %d ",*(nufano+i));
 312    fprintf(stdout,"\n");
 313
 314
 315    /* liberation memoire */
 316    free(coo);
 317    free(nomnoe);
 318    free(numnoe);
 319    free(nufano);
 320
 321    /****************************************************************************
 322    *                       LECTURE DES ELEMENTS                                *
 323    ****************************************************************************/
 324
 325    fprintf(stdout,"\n(**************************)\n");
 326    fprintf(stdout,"(* ELEMENTS DU MAILLAGE : *)\n");
 327    fprintf(stdout,"(**************************)");
 328
 329    /* Lecture des connectivites, noms, numeros des mailles */
 330    for (i=0;i<MED_NBR_GEOMETRIE_MAILLE;i++)
 331      if (nmailles[i] > 0) {
 332
 333        /* dimension de la maille */
 334        edim = typmai[i] / 100;
 335        switch(typ_con) {
 336        case MED_NOD :
 337      taille = typmai[i]%100;
 338      break;
 339
 340        case MED_DESC :
 341      taille = desmai[i];
 342      break;
 343
 344        default :
 345      ret = -1;
 346        }
 347
 348        /* allocation memoire */
 349        connectivite = (med_int*)malloc(sizeof(med_int)*taille*nmailles[i]);
 350        EXIT_IF(connectivite == NULL,NULL,NULL);
 351        nomele = (char*)malloc(sizeof(char)*MED_TAILLE_PNOM*nmailles[i]+1);
 352        EXIT_IF(nomele == NULL,NULL,NULL);
 353        numele = (med_int*)malloc(sizeof(med_int)*nmailles[i]);
 354        EXIT_IF(numele == NULL,NULL,NULL);
 355        nufael = (med_int*)malloc(sizeof(med_int)*nmailles[i]);
 356        EXIT_IF(nufael == NULL,NULL,NULL);
 357
 358        /* lecture des données */
 359        ret = MEDelementsLire(fid,nommaa,mdim,connectivite,mode_coo,
 360                    nomele,&inoele,numele,&inuele,nufael,
 361                  nmailles[i],MED_MAILLE,typmai[i],
 362                  typ_con);
 363        EXIT_IF(ret < 0,"lors de la lecture des mailles (conncetivite,numeros,noms et numeros de famille",
 364            NULL);
 365
 366        /* affichage des resultats */
 367        fprintf(stdout,"\n\n- Mailles de type %s : ", nommai[i]);
 368        fprintf(stdout,"\n  - Connectivité : \n");
 369        for (j=0;j<nmailles[i]*taille;j++)
 370      fprintf(stdout," %d ",*(connectivite+j));
 371        if (inoele) {
 372      fprintf(stdout,"\n  - Noms : \n");
 373      for (j=0;j<nmailles[i];j++) {
 374        strncpy(str,nomele+j*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
 375        str[MED_TAILLE_PNOM] = '\0';
 376        fprintf(stdout," %s ",str);
 377      }
 378        }
 379        if (inuele) {
 380      fprintf(stdout,"\n  - Numeros :\n");
 381      for (j=0;j<nmailles[i];j++)
 382        fprintf(stdout," %d ",*(numele+j));
 383        }
 384        fprintf(stdout,"\n  - Numéros de familles : \n");
 385        for (j=0;j<nmailles[i];j++)
 386      fprintf(stdout," %d ",*(nufael+j));
 387
 388        /* liberation memoire */
 389        free(connectivite);
 390        free(nomele);
 391        free(numele);
 392        free(nufael);
 393      }
 394
 395    /* lecture des mailles de type MED_POLYGONE */
 396    if (nmpolygones > 0) {
 397
 398      /* quelle taille pour  le tableau des connectivites ? */
 399      ret = MEDpolygoneInfo(fid,nommaa,MED_MAILLE,typ_con,&taille);
 400      EXIT_IF(ret < 0,"lors de la lecture des parametres des mailles MED_POLYGONE",NULL);
 401
 402      /* allocation memoire */
 403      indexp = (med_int *) malloc(sizeof(med_int)*(nmpolygones+1));
 404      EXIT_IF(indexp == NULL,NULL,NULL);
 405      connectivite = (med_int *) malloc(sizeof(med_int)*taille);
 406      EXIT_IF(connectivite == NULL,NULL,NULL);
 407      numele = (med_int *) malloc(sizeof(med_int)*nmpolygones);
 408      EXIT_IF(numele == NULL,NULL,NULL);
 409      nufael = (med_int *) malloc(sizeof(med_int)*nmpolygones);
 410      EXIT_IF(nufael == NULL,NULL,NULL);
 411      nomele = (char *) malloc(sizeof(char)*MED_TAILLE_PNOM*nmpolygones+1);
 412      EXIT_IF(nomele == NULL,NULL,NULL);
 413
 414      /* lecture de la connectivite des mailles polygones */
 415      ret = MEDpolygoneConnLire(fid,nommaa,indexp,nmpolygones+1,connectivite,
 416                    MED_MAILLE,typ_con);
 417      EXIT_IF(ret < 0,"lors de la lecture des connectivites des mailles de type MED_POLYGONE",NULL);
 418
 419      /* lecture noms */
 420      ret1 = MEDnomLire(fid,nommaa,nomele,nmpolygones,MED_MAILLE,MED_POLYGONE);
 421
 422      /* lecture des numeros */
 423      ret2 = (med_int) MEDnumLire(fid,nommaa,numele,nmpolygones,
 424                  MED_MAILLE,MED_POLYGONE);
 425
 426      /* lecture des numeros de familles */
 427      ret3 = MEDfamLire(fid,nommaa,nufael,nmpolygones,MED_MAILLE,MED_POLYGONE);
 428      if (ret3 < 0)
 429        for (i=0;i<nmpolygones;i++)
 430      *(nufael+i) = 0;
 431
 432      /* affichage des resultats */
 433      fprintf(stdout,"\n\n- Mailles de type MED_POLYGONE : ");
 434      for (i=0;i<nmpolygones;i++) {
 435        fprintf(stdout,"\n >> Maille MED_POLYGONE %d : \n",i+1);
 436        fprintf(stdout,"\n  - Connectivité : ");
 437        ind1 = *(indexp+i)-1;
 438        ind2 = *(indexp+i+1)-1;
 439        for (j=ind1;j<ind2;j++)
 440      printf(" %d ",*(connectivite+j));
 441        if (ret1 == 0) {
 442      strncpy(tmp,nomele+j*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
 443      tmp[MED_TAILLE_PNOM] = '\0';
 444      fprintf(stdout,"\n  - Nom : %s \n",tmp);
 445        }
 446        if (ret2 == 0)
 447      fprintf(stdout,"\n  - Numero : %d \n",*(numele+j));
 448        fprintf(stdout,"\n  - Numéro de famille : %d \n",*(nufael+j));
 449      }
 450
 451      /* on libere la memoire */
 452      free(indexp);
 453      free(connectivite);
 454      free(numele);
 455      free(nufael);
 456      free(nomele);
 457    }
 458
 459    /* lecture des mailles de type MED_POLYEDRE */
 460    if (npolyedres > 0) {
 461
 462      /* lecture des parametres de base */
 463      ret = MEDpolyedreInfo(fid,nommaa,typ_con,&nf,&taille);
 464      EXIT_IF(ret < 0,"lors de la lecture des parametres des mailles MED_POLYEDRE",NULL);
 465
 466      /* allocation memoire */
 467      indexp        = (med_int *) malloc(sizeof(med_int)*(npolyedres+1));
 468      EXIT_IF(indexp == NULL,NULL,NULL);
 469      indexf        = (med_int *) malloc(sizeof(med_int)*nf);
 470      EXIT_IF(indexf == NULL,NULL,NULL);
 471      connectivite  = (med_int *) malloc(sizeof(med_int)*taille);
 472      EXIT_IF(connectivite == NULL,NULL,NULL);
 473      numele        = (med_int *) malloc(sizeof(med_int)*npolyedres);
 474      EXIT_IF(numele == NULL,NULL,NULL);
 475      nufael        = (med_int *) malloc(sizeof(med_int)*npolyedres);
 476      EXIT_IF(nufael == NULL,NULL,NULL);
 477      nomele        = (char *) malloc(sizeof(char)*MED_TAILLE_PNOM*npolyedres+1);
 478      EXIT_IF(nomele == NULL,NULL,NULL);
 479
 480      /* lecture de la connectivite des mailles polyedres */
 481      ret = MEDpolyedreConnLire(fid,nommaa,indexp,npolyedres+1,indexf,nf,
 482                    connectivite,MED_NOD);
 483      EXIT_IF(ret < 0,"lors de la lecture de la connectivite des mailles MED_POLYEDRES",
 484          NULL);
 485
 486      /* lecture des noms */
 487      ret1 = MEDnomLire(fid,nommaa,nomele,npolyedres,MED_MAILLE,MED_POLYEDRE);
 488
 489      /* lecture des numeros */
 490      ret2 = MEDnumLire(fid,nommaa,numele,npolyedres,MED_MAILLE,MED_POLYEDRE);
 491
 492      /* lecture des numeros de familles */
 493      ret3 = MEDfamLire(fid,nommaa,nufael,npolyedres,MED_MAILLE,MED_POLYEDRE);
 494      if (ret3 < 0)
 495        for (i=0;i<npolyedres;i++)
 496      *(nufael+i) = 0;
 497
 498      /* affichage des resultats */
 499      fprintf(stdout,"\n\n- Mailles de type MED_POLYEDRE : ");
 500      for (i=0;i<npolyedres;i++) {
 501        fprintf(stdout,"\n >> Maille MED_POLYEDRE %d : \n",i+1);
 502        fprintf(stdout,"\n  - Connectivité : ");
 503        nfa  = *(indexp+i+1) - *(indexp+i);
 504        for (j=0;j<nfa;j++) {
 505      if (typ_con == MED_NOD) {
 506        /* ind2 = indice dans "connectivite" 
 507           pour acceder au premier noeud de la face */
 508        ind2 = *(indexf+ind1+j) - 1;
 509        nnoe = *(indexf+ind1+j+1) - *(indexf+ind1+j);
 510        fprintf(stdout,"   - Face %d : [ ", j+1);
 511        for (k=0;k<nnoe;k++)
 512          printf(" %d ",*(connectivite+ind2+k));
 513        printf(" ] \n");
 514      }
 515      else {
 516        nfa  = *(indexp+i+1) - *(indexp+i);
 517        /* ind1 = indice dans "connectivite" 
 518           pour acceder aux numeros des faces */
 519        ind1 = *(indexp+i) - 1;
 520        for (j=0;j<nfa;j++)
 521          fprintf(stdout,"   - Face %d de numero : %d et de type %d \n", j+1,
 522              *(connectivite+ind1+j),*(indexf+ind1+j));
 523      }
 524        }
 525        if (ret1 == 0) {
 526      strncpy(tmp,nomele+j*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
 527      tmp[MED_TAILLE_PNOM] = '\0';
 528      fprintf(stdout,"\n  - Nom : %s \n",tmp);
 529        }
 530        if (ret2 == 0)
 531      fprintf(stdout,"\n  - Numero : %d \n",*(numele+j));
 532        fprintf(stdout,"\n  - Numéro de famille : %d \n",*(nufael+j));
 533      }
 534
 535      /* on libere la memoire */
 536      free(indexp);
 537      free(indexf);
 538      free(connectivite);
 539      free(numele);
 540      free(nufael);
 541      free(nomele);
 542
 543    }
 544
 545    /* lecture des faces */
 546    if (typ_con == MED_DESC)
 547      for (i=0;i<MED_NBR_GEOMETRIE_FACE;i++)
 548        if (nfaces[i] > 0 ) {
 549
 550      /* dimension de la face */
 551      edim = typfac[i] / 100;
 552      switch(typ_con) {
 553      case MED_NOD :
 554        taille = typfac[i]%100;
 555        break;
 556
 557      case MED_DESC :
 558        taille = desfac[i];
 559        break;
 560
 561      default :
 562        ret = -1;
 563      }
 564
 565      /* allocation memoire */
 566      connectivite = (med_int*)malloc(sizeof(med_int)*taille*nfaces[i]);
 567      EXIT_IF(connectivite == NULL,NULL,NULL);
 568      nomele = (char*)malloc(sizeof(char)*MED_TAILLE_PNOM*nfaces[i]+1);
 569      EXIT_IF(nomele == NULL,NULL,NULL);
 570      numele = (med_int*)malloc(sizeof(med_int)*nfaces[i]);
 571      EXIT_IF(numele == NULL,NULL,NULL);
 572      nufael = (med_int*)malloc(sizeof(med_int)*nfaces[i]);
 573      EXIT_IF(nufael == NULL,NULL,NULL);
 574
 575      /* lecture des données */
 576      ret = MEDelementsLire(fid,nommaa,mdim,connectivite,mode_coo,
 577                    nomele,&inoele,numele,&inuele,nufael,
 578                    nfaces[i],MED_FACE,typfac[i],
 579                    typ_con);
 580      EXIT_IF(ret < 0,"lors de la lecture des faces (connectivite,noms,numeros,numeros de familles)",
 581          NULL);
 582
 583      /* affichage des resultats */
 584      fprintf(stdout,"\n- Faces de type %s : ", nomfac[i]);
 585      fprintf(stdout,"\n  - Connectivité : \n");
 586      for (j=0;j<nfaces[i]*taille;j++)
 587        fprintf(stdout," %d ",*(connectivite+j));
 588      if (inoele) {
 589        fprintf(stdout,"\n  - Noms : \n");
 590        for (j=0;j<nfaces[i];j++) {
 591          fprintf(stdout," %d ",*(connectivite+j));
 592          strncpy(str,nomele+j*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
 593          str[MED_TAILLE_PNOM] = '\0';
 594          fprintf(stdout," %s ",str);
 595        }
 596      }
 597      if (inuele) {
 598        fprintf(stdout,"\n  - Numeros :\n");
 599        for (j=0;j<nfaces[i];j++)
 600          fprintf(stdout," %d ",*(numele+j));
 601      }
 602      fprintf(stdout,"\n  - Numéros de familles : \n");
 603      for (j=0;j<nfaces[i];j++)
 604        fprintf(stdout," %d ",*(nufael+j));
 605
 606      /* liberation memoire */
 607      free(connectivite);
 608      free(nomele);
 609      free(numele);
 610      free(nufael);
 611        }
 612
 613
 614    /* lecture des faces de type MED_POLYGONE */
 615    if (nfpolygones > 0) {
 616
 617      /* quelle taille pour  le tableau des connectivites ? */
 618      ret = MEDpolygoneInfo(fid,nommaa,MED_FACE,typ_con,&taille);
 619      EXIT_IF(ret < 0,"lors de la lecture des parametres des faces MED_POLYGONE",NULL);
 620
 621      /* allocation memoire */
 622      indexp = (med_int *) malloc(sizeof(med_int)*(nfpolygones+1));
 623      EXIT_IF(indexp == NULL,NULL,NULL);
 624      connectivite = (med_int *) malloc(sizeof(med_int)*taille);
 625      EXIT_IF(connectivite == NULL,NULL,NULL);
 626      numele = (med_int *) malloc(sizeof(med_int)*nfpolygones);
 627      EXIT_IF(numele == NULL,NULL,NULL);
 628      nufael = (med_int *) malloc(sizeof(med_int)*nfpolygones);
 629      EXIT_IF(nufael == NULL,NULL,NULL);
 630      nomele = (char *) malloc(sizeof(char)*MED_TAILLE_PNOM*nfpolygones+1);
 631      EXIT_IF(nomele == NULL,NULL,NULL);
 632
 633      /* lecture de la connectivite des faces polygones */
 634      ret = MEDpolygoneConnLire(fid,nommaa,indexp,nfpolygones+1,connectivite,
 635                    MED_FACE,typ_con);
 636      EXIT_IF(ret < 0,"lors de la lecture des connectivites des faces de type MED_POLYGONE",NULL);
 637
 638      /* lecture noms */
 639      ret1 = MEDnomLire(fid,nommaa,nomele,nfpolygones,MED_FACE,MED_POLYGONE);
 640
 641      /* lecture des numeros */
 642      ret2 = (med_int) MEDnumLire(fid,nommaa,numele,nfpolygones,
 643                  MED_FACE,MED_POLYGONE);
 644
 645      /* lecture des numeros de familles */
 646      ret3 = MEDfamLire(fid,nommaa,nufael,nfpolygones,MED_FACE,MED_POLYGONE);
 647      if (ret3 < 0)
 648        for (i=0;i<nfpolygones;i++)
 649      *(nufael+i) = 0;
 650
 651      /* affichage des resultats */
 652      fprintf(stdout,"\n\n- Faces de type MED_POLYGONE : ");
 653      for (i=0;i<nfpolygones;i++) {
 654        fprintf(stdout,"\n >> Face MED_POLYGONE %d : \n",i+1);
 655        fprintf(stdout,"\n  - Connectivité : ");
 656        ind1 = *(indexp+i)-1;
 657        ind2 = *(indexp+i+1)-1;
 658        for (j=ind1;j<ind2;j++)
 659      fprintf(stdout," %d ",*(connectivite+j));
 660        if (ret1 == 0) {
 661      strncpy(tmp,nomele+j*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
 662      tmp[MED_TAILLE_PNOM] = '\0';
 663      fprintf(stdout,"\n  - Nom : %s \n",tmp);
 664        }
 665        if (ret2 == 0)
 666      fprintf(stdout,"\n  - Numero : %d \n",*(numele+j));
 667        fprintf(stdout,"\n  - Numéro de famille : %d \n",*(nufael+j));
 668      }
 669
 670      /* on libere la memoire */
 671      free(indexp);
 672      free(connectivite);
 673      free(numele);
 674      free(nufael);
 675      free(nomele);
 676    }
 677
 678    /* les aretes */
 679    if (typ_con == MED_DESC)
 680      for (i=0;i<MED_NBR_GEOMETRIE_ARETE;i++)
 681        if (naretes[i] > 0) {
 682
 683      /* dimension de l'arete  */
 684      edim = typare[i] / 100;
 685      switch(typ_con) {
 686      case MED_NOD :
 687        taille = typare[i]%100;
 688        break;
 689
 690      case MED_DESC :
 691        taille = desare[i];
 692        break;
 693
 694      default :
 695        ret = -1;
 696      }
 697
 698      /* allocation memoire */
 699      connectivite = (med_int*)malloc(sizeof(med_int)*taille*naretes[i]);
 700      EXIT_IF(connectivite == NULL,NULL,NULL);
 701      nomele = (char*)malloc(sizeof(char)*MED_TAILLE_PNOM*naretes[i]+1);
 702      EXIT_IF(nomele == NULL,NULL,NULL);
 703      numele = (med_int*)malloc(sizeof(med_int)*naretes[i]);
 704      EXIT_IF(numele == NULL,NULL,NULL);
 705      nufael = (med_int*)malloc(sizeof(med_int)*naretes[i]);
 706      EXIT_IF(nufael == NULL,NULL,NULL);
 707
 708      /* lecture des données */
 709      ret = MEDelementsLire(fid,nommaa,mdim,connectivite,mode_coo,
 710                    nomele,&inoele,numele,&inuele,nufael,
 711                    naretes[i],MED_ARETE,typare[i],
 712                    typ_con);
 713      EXIT_IF(ret < 0,"lors de la lecture des aretes (connectivite,noms,numeros,numeros de familles)",
 714          NULL);
 715
 716      /* affichage des resultats */
 717      fprintf(stdout,"\n- Aretes de type %d : ", nomare[i]);
 718      fprintf(stdout,"\n  - Connectivité : \n");
 719      for (j=0;j<naretes[i]*taille;j++)
 720        fprintf(stdout," %d ",*(connectivite+j));
 721      if (inoele) {
 722        fprintf(stdout,"\n  - Noms : \n");
 723        for (j=0;j<naretes[i];j++) {
 724          fprintf(stdout," %d ",*(connectivite+j));
 725          strncpy(str,nomele+j*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
 726          str[MED_TAILLE_PNOM] = '\0';
 727          fprintf(stdout," %s ",str);
 728        }
 729      }
 730      if (inuele) {
 731        fprintf(stdout,"\n  - Numeros :\n");
 732        for (j=0;j<naretes[i];j++)
 733          fprintf(stdout," %d ",*(numele+j));
 734      }
 735      fprintf(stdout,"\n  - Numéros de familles : \n");
 736      for (j=0;j<naretes[i];j++)
 737        fprintf(stdout," %d ",*(nufael+j));
 738
 739      /* liberation memoire */
 740      free(connectivite);
 741      free(nomele);
 742      free(numele);
 743      free(nufael);
 744        }
 745
 746    /****************************************************************************
 747     *                       LECTURE DES FAMILLES                                *
 748     ****************************************************************************/
 749    printf("\n(*************************)\n");
 750    printf("(* FAMILLES DU MAILLAGE : *)\n");
 751    printf("(*************************)\n");
 752
 753    for (i=0;i<nfam;i++) {
 754
 755      /* nombre de groupes */
 756      ngro = MEDnGroupe(fid,nommaa,i+1);
 757      EXIT_IF(ngro < 0,"lors de la lecture du nombre de groupe d'une famille",NULL);
 758
 759      /* nombre d'attributs */
 760      natt = MEDnAttribut(fid,nommaa,i+1);
 761      EXIT_IF(natt < 0,"lors de la lecture du nombre d'attributs d'une famille",NULL);
 762
 763      fprintf(stdout,"- Famille %d a %d attribut(s) et %d groupe(s) \n",i+1,natt,ngro);
 764
 765      /* nom,numero,attributs,groupes */
 766
 767      /* allocation memoire */
 768      attide = (med_int*) malloc(sizeof(med_int)*natt);
 769      EXIT_IF(attide == NULL,NULL,NULL);
 770      attval = (med_int*) malloc(sizeof(med_int)*natt);
 771      EXIT_IF(attval == NULL,NULL,NULL);
 772      attdes = (char *) malloc(MED_TAILLE_DESC*natt+1);
 773      EXIT_IF(attdes == NULL,NULL,NULL);
 774      gro = (char*) malloc(MED_TAILLE_LNOM*ngro+1);
 775      EXIT_IF(gro == NULL,NULL,NULL);
 776
 777      ret = MEDfamInfo(fid,nommaa,i+1,nomfam,&numfam,attide,attval,
 778               attdes,&natt,gro,&ngro);
 779      EXIT_IF(ret < 0,"lors de la lecture des informations d'une famille",
 780          NULL);
 781
 782      /* affichage des resultats */
 783      fprintf(stdout,"  - Famille de nom %s et de numero %d : \n",nomfam,numfam);
 784      fprintf(stdout,"  - Attributs : \n");
 785      for (j=0;j<natt;j++) {
 786        strncpy(str1,attdes+j*MED_TAILLE_DESC,MED_TAILLE_DESC);
 787        str1[MED_TAILLE_DESC] = '\0';
 788        fprintf(stdout,"   identificateur = %d - valeur = %d - description = %s\n",*(attide+j),
 789            *(attval+j),str1);
 790      }
 791
 792      free(attide);
 793      free(attval);
 794      free(attdes);
 795
 796      fprintf(stdout,"  - Groupes :\n");
 797      for (j=0;j<ngro;j++) {
 798        strncpy(str2,gro+j*MED_TAILLE_LNOM,MED_TAILLE_LNOM);
 799        str2[MED_TAILLE_LNOM] = '\0';
 800        fprintf(stdout,"   groupe %d  = %s\n",j,str2);
 801      }
 802
 803      free(gro);
 804    }
 805
 806
 807
 808    /****************************************************************************
 809     *                       LECTURE DES EQUIVALENCES                            *
 810     ****************************************************************************/
 811    fprintf(stdout,"\n(******************************)\n");
 812    fprintf(stdout,"(* EQUIVALENCES DU MAILLAGE : *)\n");
 813    fprintf(stdout,"(******************************)\n");
 814
 815    if (nequ == 0)
 816      fprintf(stdout,"- Aucune équivalence \n");
 817
 818    /* lecture de toutes les equivalences associes a nommaa */
 819    for (i = 0;i<nequ;i++) {
 820      fprintf(stdout,"- Equivalence numero : %d ",i+1);
 821
 822      /* lecture des infos sur l'equivalence */
 823      ret = MEDequivInfo(fid,nommaa,i+1,equ,des);
 824      EXIT_IF(ret < 0,"lors de la lecture des informations sur une equivalence",
 825          NULL);
 826      fprintf(stdout,"\n  - Nom de l'equivalence: %s \n",equ);
 827      fprintf(stdout,"\n  - Description de l'equivalence : %s \n",des);
 828
 829      /* lecture des correspondances sur les differents types d'entites */
 830
 831      /* les noeuds */
 832      ncor = MEDnCorres(fid,nommaa,equ,MED_NOEUD,0);
 833      EXIT_IF(ncor < 0,"lors de la lecture du nombre de correspondances d'une equivalence",
 834          NULL);
 835      fprintf(stdout,"\n  - Il y a %d correspondances sur les noeuds \n",ncor);
 836
 837      if (ncor > 0) {
 838
 839        /* allocation memoire */
 840        cor = (med_int*) malloc(sizeof(med_int)*ncor*2);
 841        EXIT_IF(cor == NULL,NULL,NULL);
 842
 843        ret = MEDequivLire(fid,nommaa,equ,cor,ncor,MED_NOEUD,0);
 844        EXIT_IF(ret < 0,"lors de la lecture du tableau des correspondances",
 845            NULL);
 846        for (j=0;j<ncor;j++)
 847      fprintf(stdout,"\n  - Correspondance %d : %d et %d \n",j+1,*(cor+2*j),
 848                *(cor+2*j+1));
 849        free(cor);
 850      }
 851
 852      /* sur les mailles : on ne prend pas en compte les mailles 3D */
 853      for (j=0;j<NBR_MAILLE_EQU;j++) {
 854
 855        ncor = MEDnCorres(fid,nommaa,equ,MED_MAILLE,typmai[j]);
 856        EXIT_IF(ncor < 0,"lors de la lecture du nombre de correspondances dans une equivalence",
 857            NULL);
 858        fprintf(stdout,"\n  - Il y a %d correspondances sur les mailles %s \n",ncor,
 859            nommai[j]);
 860
 861        if (ncor > 0) {
 862
 863      /* allocation memoire */
 864      cor = (med_int*) malloc(sizeof(med_int)*ncor*2);
 865      EXIT_IF(cor == NULL,NULL,NULL);
 866
 867      ret = MEDequivLire(fid,nommaa,equ,cor,ncor,MED_MAILLE,
 868                 typmai[j]);
 869      EXIT_IF(ret < 0,"lors de la lecture du tableau des equivalences",
 870          NULL);
 871
 872      for (k=0;k<ncor;k++)
 873        fprintf(stdout,"\n  - Correspondance %d : %d et %d \n",k+1,*(cor+2*k),
 874            *(cor+2*k+1));
 875
 876      free(cor);
 877        }
 878      }
 879
 880      /* sur les faces */
 881      for (j=0;j<MED_NBR_GEOMETRIE_FACE;j++) {
 882
 883        ncor = MEDnCorres(fid,nommaa,equ,MED_FACE,typfac[j]);
 884        EXIT_IF(ncor < 0,"lors de la lecture du nombre de correspondances dans une equivalence",
 885            NULL);
 886        fprintf(stdout,"\n  - Il y a %d correspondances sur les faces %s\n",ncor,
 887            nomfac[j]);
 888
 889        if (ncor > 0) {
 890
 891      /* allocation memoire */
 892      cor = (med_int*) malloc(sizeof(med_int)*ncor*2);
 893      EXIT_IF(cor == NULL,NULL,NULL);
 894
 895      ret = MEDequivLire(fid,nommaa,equ,cor,ncor,MED_FACE,
 896                 typfac[j]);
 897      EXIT_IF(ret < 0,"lors de la lecture du tableau des equivalences",
 898          NULL);
 899
 900      for (k=0;k<ncor;k++)
 901        fprintf(stdout,"\n  - Correspondance %d : %d et %d \n",k+1,*(cor+2*k),
 902                *(cor+2*k+1));
 903
 904      free(cor);
 905        }
 906      }
 907
 908      /*  sur les aretes */
 909      for (j=0;j<MED_NBR_GEOMETRIE_ARETE;j++) {
 910
 911        ncor = MEDnCorres(fid,nommaa,equ,MED_ARETE,typare[j]);
 912        EXIT_IF(ncor < 0,"lors de la lecture du nombre de correspondances",
 913            NULL);
 914        fprintf(stdout,"\n  - Il y a %d correspondances sur les aretes %s \n",
 915            ncor,nomare[j]);
 916
 917        if (ncor > 0) {
 918
 919      /* allocation memoire */
 920      cor = (med_int*) malloc(sizeof(med_int)*ncor*2);
 921      EXIT_IF(cor == NULL,NULL,NULL);
 922
 923      ret = MEDequivLire(fid,nommaa,equ,cor,ncor,MED_ARETE,
 924                 typare[j]);
 925      EXIT_IF(ret < 0,"lors de la lecture du tableau des equivalences",
 926          NULL);
 927
 928      for (k=0;k<ncor;k++)
 929        fprintf(stdout,"\n  Correspondance %d : %d et %d \n",k+1,*(cor+2*k),
 930              *(cor+2*k+1));
 931
 932      free(cor);
 933        }
 934      }
 935    }
 936
 937    return;
 938  }
 939
 940
 941  /******************************************************************************
 942   *
 943   * - Nom de la fonction : lecture_maillage_structure
 944   * - Description : lecture et affichage d'un maillage MED__STRUCTURE.
 945   * - Parametres :
 946   *     - fid                       (IN) : ID du fichier MED.
 947   *     - nommaa                    (IN) : nom du maillage a lire.
 948   *     - mdim                      (IN) : dimension du maillage.
 949   *     - mode_coo                  (IN) : mode de stockage en memoire : 
 950   *                                        MED_FULL_INTERLACE | MED_NO_INTERLACE.
 951   *     - lecture_en_tete_seulement (IN) : mode de lecture.
 952   *
 953   ******************************************************************************/
 954
 955  void lecture_maillage_structure(med_idt fid,char *nommaa,med_int mdim,
 956                  med_mode_switch mode_coo,int lecture_en_tete_seulement)
 957  {
 958    med_err ret = 0;
 959    med_int axe,i,j;
 960    med_int nind;
 961    char comp_ind[MED_TAILLE_PNOM+1];
 962    char unit_ind[MED_TAILLE_PNOM+1];
 963    char comp[3*MED_TAILLE_PNOM+1];
 964    char unit[3*MED_TAILLE_PNOM+1];
 965    char str[MED_TAILLE_PNOM+1];
 966    med_float *coo,*indices;
 967    med_int *structure_grille;
 968    med_table quoi;
 969    med_int nnoe;
 970    med_type_grille type;
 971    med_repere repere;
 972    /* familles */
 973    med_int nfam;
 974    med_int natt,ngro;
 975    char *attdes,*gro;
 976    med_int *attval,*attide;
 977    char nomfam[MED_TAILLE_NOM+1];
 978    med_int numfam, *nufano;
 979    char str1[MED_TAILLE_DESC+1];
 980    char str2[MED_TAILLE_LNOM+1];
 981
 982    ret = MEDnatureGrilleLire(fid,nommaa,&type);
 983    EXIT_IF(ret < 0,"lors de lecture du type d'une grille ",NULL);
 984
 985    switch(type) {
 986
 987    case MED_GRILLE_CARTESIENNE:
 988      fprintf(stdout,"- Type de grille : MED_GRILLE_CARTESIENNE \n");
 989      nnoe = 1;
 990      for (axe=1;axe<=mdim;axe++) {
 991        switch(axe) {
 992
 993        case 1:
 994      quoi = MED_COOR_IND1;
 995      break;
 996
 997        case 2:
 998      quoi = MED_COOR_IND2;
 999      break;
1000
1001        case 3:
1002      quoi = MED_COOR_IND3;
1003      break;
1004        }
1005        nind = MEDnEntMaa(fid,nommaa,quoi,MED_NOEUD,0,0);
1006        nnoe = nind * nnoe;
1007        EXIT_IF(nind < 0,"lors de la lecture de la taille d'un indice d'une grille",
1008            NULL);
1009        fprintf(stdout,"- Taille de l'indice de l'axe %d des coordonnees : %d \n",axe,nind);
1010      }
1011      break;
1012
1013
1014    case MED_GRILLE_POLAIRE:
1015      fprintf(stdout,"- Type de grille : MED_GRILLE_POLAIRE \n");
1016      nnoe = 1;
1017      for (axe=1;axe<=mdim;axe++) {
1018        switch(axe) {
1019
1020        case 1:
1021      quoi = MED_COOR_IND1;
1022      break;
1023
1024        case 2:
1025      quoi = MED_COOR_IND2;
1026      break;
1027
1028        case 3:
1029      quoi = MED_COOR_IND3;
1030      break;
1031        }
1032        nind = MEDnEntMaa(fid,nommaa,quoi,MED_NOEUD,0,0);
1033        nnoe = nind * nnoe;
1034        EXIT_IF(nind < 0,"lors de la lecture de la taille d'un indice d'une grille",
1035            NULL);
1036        fprintf(stdout,"- Taille de l'indice de l'axe %d des coordonnees : %d \n",axe,nind);
1037      }
1038      break;
1039
1040    case MED_GRILLE_STANDARD:
1041      fprintf(stdout,"- Type de grille : MED_GRILLE_DESTRUCTUREE \n");
1042      nnoe = MEDnEntMaa(fid,nommaa,MED_COOR,MED_NOEUD,0,0);
1043      EXIT_IF(nnoe < 0,"lors de la lecture du nombre de noeuds du maillage ",nommaa);
1044      fprintf(stdout,"- Nombre de noeuds : %d \n",nnoe);
1045      break;
1046    }
1047
1048    /* nombre de familles */
1049    nfam = MEDnFam(fid,nommaa);
1050    EXIT_IF(nfam < 0,"lors de la lecture du nombre de familles",NULL);
1051    fprintf(stdout,"- Nombre de familles : %d \n",nfam);
1052
1053    if (lecture_en_tete_seulement)
1054      return ;
1055
1056    fprintf(stdout,"\n(*************************)\n");
1057    fprintf(stdout,"(* NOEUDS DE LA GRILLE : *)\n");
1058    fprintf(stdout,"(*************************)\n");
1059
1060    switch(type) {
1061
1062    case MED_GRILLE_CARTESIENNE :
1063    case MED_GRILLE_POLAIRE :
1064      /* on affiche les coordonnees de chacun des axes */
1065      for (axe = 1; axe<=mdim; axe++) {
1066        /* on alloue la memoire */
1067        indices = (med_float *) malloc(sizeof(med_float)*nind);
1068        EXIT_IF(indices == NULL,NULL,NULL);
1069        /* on lit le tableau des indices de coordonnees 
1070           et on affiche le resultat */
1071        ret = MEDindicesCoordLire(fid,nommaa,mdim,indices,nind,
1072                  axe,comp_ind,unit_ind);
1073        EXIT_IF(ret < 0,"lors de la lecture d'un tableau d'indice",
1074            NULL);
1075        fprintf(stdout,"\n - Axe %s [%s] : [ ",comp_ind,unit_ind);
1076        for (j=0;j<nind;j++)
1077      fprintf(stdout," %f ",*(indices+j));
1078        printf(" ] \n");
1079        /* on nettoie la memoire */
1080        free(indices);
1081      }
1082      break;
1083
1084    case MED_GRILLE_STANDARD:
1085      /* on alloue la memoire */
1086      structure_grille = (med_int *) malloc(sizeof(med_int)*mdim);
1087      EXIT_IF(structure_grille == NULL,NULL,NULL);
1088      /* on lit la structure de la grille 
1089         et on affiche le resultat */
1090      ret = MEDstructureCoordLire(fid,nommaa,mdim,structure_grille);
1091      EXIT_IF(ret < 0,"lors de la lecture de la structure de la grille",
1092          NULL);
1093      for (j=0;j<mdim;j++)
1094        fprintf(stdout," %d ",*(structure_grille+j));
1095      fprintf(stdout," ] \n");
1096      /* on nettoie la memoire */
1097      free(structure_grille);
1098
1099      /* on alloue la memoire */
1100      coo = (med_float *) malloc(sizeof(med_float)*nnoe*mdim);
1101      EXIT_IF(coo == NULL,NULL,NULL);
1102      /* on va lire les coordonnees des noeuds */
1103      ret = MEDcoordLire(fid,nommaa,mdim,coo,MED_FULL_INTERLACE,MED_ALL,NULL,0,
1104                   &repere,comp,unit);
1105      EXIT_IF(ret < 0,"lors de la lecture des noeuds du maillage",NULL);
1106      /* on affiche le resultat */
1107      fprintf(stdout,"- Nom des coordonnees : \n");
1108      for (i=0;i<mdim;i++) {
1109        strncpy(str,comp+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
1110        str[MED_TAILLE_PNOM] = '\0';
1111        fprintf(stdout," %s ",str);
1112      }
1113      fprintf(stdout,"\n- Unites des coordonnees : \n");
1114      for (i=0;i<mdim;i++) {
1115        strncpy(str,unit+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
1116        str[MED_TAILLE_PNOM] = '\0';
1117        fprintf(stdout," %s ",str);
1118      }
1119      fprintf(stdout,"\n - Coordonnees des noeuds : [ ");
1120      for (j=0;j<nnoe*mdim;j++)
1121        fprintf(stdout," %f ",*(coo+j));
1122      fprintf(stdout," ] \n");
1123      /* on nettoie la memoire */
1124      free(coo);
1125      break;
1126    }
1127
1128    /* lecture des numeros de familles de noeuds */
1129
1130    /* on alloue la memoire */
1131    nufano = (med_int *) malloc(sizeof(med_int)*nnoe);
1132    EXIT_IF(nufano == NULL,NULL,NULL);
1133
1134    /* on va lire les numeros de familles des noeuds */
1135    ret = MEDfamLire(fid,nommaa,nufano,nnoe,MED_NOEUD,0);
1136    EXIT_IF(ret < 0,"lors de la lecture des numeros de familles des noeuds",
1137        NULL);
1138
1139    /* on affiche le resultat */
1140    fprintf(stdout,"\n- Numeros des familles des noeuds : \n");
1141    for (i=0;i<nnoe;i++)
1142      fprintf(stdout," %d ",*(nufano+i));
1143    fprintf(stdout,"\n");
1144
1145    printf("\n(*************************)\n");
1146    printf("(* FAMILLES DU MAILLAGE : *)\n");
1147    printf("(*************************)\n");
1148
1149    for (i=0;i<nfam;i++) {
1150
1151      /* nombre de groupes */
1152      ngro = MEDnGroupe(fid,nommaa,i+1);
1153      EXIT_IF(ngro < 0,"lors de la lecture du nombre de groupe d'une famille",NULL);
1154
1155      /* nombre d'attributs */
1156      natt = MEDnAttribut(fid,nommaa,i+1);
1157      EXIT_IF(natt < 0,"lors de la lecture du nombre d'attributs d'une famille",NULL);
1158
1159      fprintf(stdout,"- Famille %d a %d attributs et %d groupes \n",i+1,natt,ngro);
1160
1161      /* nom,numero,attributs,groupes */
1162
1163      /* allocation memoire */
1164      attide = (med_int*) malloc(sizeof(med_int)*natt);
1165      EXIT_IF(attide == NULL,NULL,NULL);
1166      attval = (med_int*) malloc(sizeof(med_int)*natt);
1167      EXIT_IF(attval == NULL,NULL,NULL);
1168      attdes = (char *) malloc(MED_TAILLE_DESC*natt+1);
1169      EXIT_IF(attdes == NULL,NULL,NULL);
1170      gro = (char*) malloc(MED_TAILLE_LNOM*ngro+1);
1171      EXIT_IF(gro == NULL,NULL,NULL);
1172
1173      ret = MEDfamInfo(fid,nommaa,i+1,nomfam,&numfam,attide,attval,
1174               attdes,&natt,gro,&ngro);
1175      EXIT_IF(ret < 0,"lors de la lecture des informations d'une famille",
1176          NULL);
1177
1178      /* affichage des resultats */
1179      fprintf(stdout,"  - Famille de nom %s et de numero %d : \n",nomfam,numfam);
1180      fprintf(stdout,"  - Attributs : \n");
1181      for (j=0;j<natt;j++) {
1182        strncpy(str1,attdes+j*MED_TAILLE_DESC,MED_TAILLE_DESC);
1183        str1[MED_TAILLE_DESC] = '\0';
1184        fprintf(stdout,"   ide = %d - val = %d - des = %s\n",*(attide+j),
1185            *(attval+j),str1);
1186      }
1187
1188      free(attide);
1189      free(attval);
1190      free(attdes);
1191
1192      fprintf(stdout,"  - Groupes :\n");
1193      for (j=0;j<ngro;j++) {
1194        strncpy(str2,gro+j*MED_TAILLE_LNOM,MED_TAILLE_LNOM);
1195        str2[MED_TAILLE_LNOM] = '\0';
1196        fprintf(stdout,"   gro = %s\n",str2);
1197      }
1198
1199      free(gro);
1200    }
1201
1202    return ;
1203  }
1204
1205
1206  med_err getFieldsOn(med_idt fid, char * nomcha, med_type_champ typcha, med_int ncomp,
1207              med_entite_maillage entite, med_mode_switch stockage) {
1208
1209    int j,k,l,m,n,nb_geo;
1210    med_int nbpdtnor=0,pflsize,*pflval,ngauss=0,*vale=NULL,nval;
1211    med_int numdt=0,numo=0,lnsize,nbrefmaa;
1212    med_float *valr=NULL,dt=0.0;
1213    med_err ret=0;
1214    med_booleen local;
1215    char pflname [MED_TAILLE_NOM+1]="";
1216    char locname [MED_TAILLE_NOM+1]="";
1217    char * lien = NULL;
1218    char maa_ass [MED_TAILLE_NOM+1]="";
1219    char dt_unit [MED_TAILLE_PNOM+1]="";
1220
1221
1222    med_geometrie_element * type_geo;
1223    med_geometrie_element typ_noeud[1] = { MED_NONE };
1224    med_geometrie_element typmai[MED_NBR_GEOMETRIE_MAILLE+2] = {MED_POINT1, MED_SEG2, MED_SEG3, MED_TRIA3,
1225                                    MED_QUAD4, MED_TRIA6,MED_QUAD8, MED_TETRA4,
1226                                    MED_PYRA5, MED_PENTA6, MED_HEXA8, MED_TETRA10,
1227                                    MED_PYRA13, MED_PENTA15, MED_HEXA20,
1228                                    MED_POLYGONE, MED_POLYEDRE};
1229    med_geometrie_element typfac[MED_NBR_GEOMETRIE_FACE+1] = {MED_TRIA3,MED_TRIA6,
1230                                  MED_QUAD4,MED_QUAD8,
1231                                  MED_POLYGONE};
1232    med_geometrie_element typare[MED_NBR_GEOMETRIE_ARETE] = {MED_SEG2,MED_SEG3};
1233
1234    char ** AFF;
1235
1236    switch (entite) {
1237    case MED_NOEUD :
1238      type_geo = typ_noeud;
1239      nb_geo   = 1;
1240      AFF      = MED_GEOMETRIE_NOEUD_AFF;
1241      break;
1242    case  MED_MAILLE :
1243      type_geo = typmai;
1244      nb_geo   = MED_NBR_GEOMETRIE_MAILLE+2;
1245      AFF      =  MED_GEOMETRIE_MAILLE_AFF;
1246      break;
1247    case  MED_FACE :
1248      type_geo = typfac;
1249      nb_geo   = MED_NBR_GEOMETRIE_FACE+1;
1250      AFF      =  MED_GEOMETRIE_FACE_AFF;
1251      break;
1252    case  MED_ARETE :
1253      type_geo = typare;
1254      nb_geo   = MED_NBR_GEOMETRIE_ARETE;
1255      AFF      =  MED_GEOMETRIE_ARETE_AFF;
1256     break;
1257    }
1258
1259
1260    for (k=0;k<nb_geo;k++) {
1261
1262      /* Combien de (PDT,NOR) a lire */
1263      nbpdtnor = MEDnPasdetemps(fid,nomcha,entite,type_geo[k]);
1264      if (nbpdtnor < 1 ) continue;
1265
1266      for (j=0;j<nbpdtnor;j++) {
1267
1268        if ( MEDpasdetempsInfo(fid,nomcha,entite,type_geo[k],
1269                   j+1, &ngauss, &numdt, &numo, dt_unit,
1270                   &dt, maa_ass, &local, &nbrefmaa) <0) {
1271      MESSAGE("Erreur a la demande d'information sur (pdt,nor) : ");
1272      ISCRUTE(numdt); ISCRUTE(numo);
1273      ret = -1; continue;
1274        };
1275
1276        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);
1277
1278        printf("\tLe maillage par defaut est : |%s|, sur un total de : %i maillages associes\n",
1279           maa_ass, nbrefmaa);
1280
1281        /* Le maillage reference est-il porte par un autre fichier */
1282        if ( !local ) {
1283
1284      if ( (lnsize=MEDnValLien(fid,maa_ass) ) < 0 )  {
1285        MESSAGE("Erreur a la lecture de la taille du lien : ");
1286        SSCRUTE(maa_ass);
1287        ret = -1;
1288      } else {
1289
1290        lien = malloc(lnsize*sizeof(char));
1291        EXIT_IF(lien == NULL,NULL,NULL);
1292
1293        if ( MEDlienLire(fid, lien, maa_ass) < 0 )  {
1294          MESSAGE("Erreur a la lecture du lien : ");
1295          SSCRUTE(maa_ass);SSCRUTE(lien);
1296          ret = -1;
1297        } else {
1298          printf("\tLe maillage |%s| est porte par un fichier distant |%s|\n",maa_ass,lien);
1299        }
1300        free(lien);
1301      }
1302        }
1303
1304        /* Combien de maillages lies aux (nomcha,ent,geo,numdt,numo)  */
1305        /* Notons que cette information est egalement disponible a partir de MEDpasdetempsInfo */
1306        if ( (nbrefmaa = MEDnChampRef(fid,nomcha,entite,type_geo[k],numdt,numo) ) < 0 ) {
1307      MESSAGE("Erreur a la demande du nombre de maillages references par le champ : ");
1308      SSCRUTE(nomcha); ISCRUTE(numdt); ISCRUTE(numo);
1309      ret = -1; continue;
1310        };
1311
1312        for (l=0;l<nbrefmaa;l++) {
1313
1314      if ( MEDchampRefInfo(fid,nomcha,entite,type_geo[k],
1315                   l+1,numdt, numo, maa_ass, &local, &ngauss) <0 ) {
1316        MESSAGE("Erreur a la demande d'information sur le maillage utilise par le champ n° : ");
1317        ISCRUTE(l+1);
1318        ret = -1; continue;
1319      };
1320
1321      /* Prend en compte le nbre de pt de gauss automatiquement */
1322      if ((nval = MEDnVal(fid,nomcha,entite,type_geo[k],numdt,numo,maa_ass,USER_MODE)) <= 0)   {
1323        MESSAGE("Erreur a la lecture du nombre de valeurs du champ : ");
1324        SSCRUTE(nomcha);ISCRUTE(entite);ISCRUTE(type_geo[k]);
1325        ISCRUTE(numdt);ISCRUTE(numo);SSCRUTE(maa_ass);ISCRUTE(USER_MODE);
1326        ret = -1; continue;
1327      };
1328
1329
1330      printf("\t- Il y a %d valeurs en mode %i. Chaque entite %s\
1331   de type geometrique %s associes au maillage |%s| a %i pts de gauss \n",
1332             nval,USER_MODE,MED_ENTITE_MAILLAGE_AFF[(int)entite],AFF[k],maa_ass,ngauss);
1333
1334      /* Le maillage reference est-il porte par un autre fichier */
1335      if ( !local ) {
1336
1337        if ( (lnsize=MEDnValLien(fid,maa_ass) ) < 0 )  {
1338          MESSAGE("Erreur a la lecture de la taille du lien : ");
1339          SSCRUTE(maa_ass);
1340          ret = -1;
1341        } else {
1342
1343          lien = malloc(lnsize*sizeof(char));
1344          EXIT_IF(lien == NULL,NULL,NULL);
1345
1346          if ( MEDlienLire(fid, lien, maa_ass) < 0 )  {
1347            MESSAGE("Erreur a la lecture du lien : ");
1348            SSCRUTE(maa_ass);SSCRUTE(lien);
1349            ret = -1;
1350          } else {
1351            printf("\tLe maillage |%s| est porte par un fichier distant |%s|\n",maa_ass,lien);
1352          }
1353          free(lien);
1354        }
1355      }
1356
1357      /*Lecture des valeurs du champ */
1358      if (typcha == MED_FLOAT64) {
1359
1360        valr = (med_float*) calloc(ncomp*nval,sizeof(med_float));
1361        EXIT_IF(valr == NULL,NULL,NULL);
1362        if ( MEDchampLire(fid,maa_ass,nomcha,(unsigned char*)valr,stockage,MED_ALL,locname,
1363                  pflname,USER_MODE,entite,type_geo[k],numdt,numo) < 0 ) {
1364          MESSAGE("Erreur a la lecture du nombre de valeurs du champ : ");
1365          SSCRUTE(nomcha);ISCRUTE(entite);ISCRUTE(type_geo[k]);
1366          ISCRUTE(numdt);ISCRUTE(numo);SSCRUTE(maa_ass);
1367          ret = -1;
1368        };
1369
1370      } else {
1371
1372        vale = (med_int*) calloc(ncomp*nval,sizeof(med_int));
1373        EXIT_IF(vale == NULL,NULL,NULL);
1374        if ( MEDchampLire(fid,maa_ass,nomcha,(unsigned char*)vale,stockage,MED_ALL,locname,
1375                  pflname,USER_MODE,entite,type_geo[k],numdt,numo) < 0 ) {
1376          MESSAGE("Erreur a la lecture des valeurs du champ : ");
1377          SSCRUTE(nomcha);ISCRUTE(entite);ISCRUTE(type_geo[k]);
1378          ISCRUTE(numdt);ISCRUTE(numo);SSCRUTE(maa_ass);
1379          ret = -1;
1380        };
1381
1382      }
1383
1384        switch (stockage) {
1385
1386        case MED_FULL_INTERLACE :
1387      printf("\t- Valeurs :\n\t");
1388      for (m=0;m<nval/ngauss;m++) {
1389        printf("|");
1390        for (n=0;n<ngauss*ncomp;n++)
1391          if (typcha == MED_FLOAT64)
1392            printf(" %f ",*(valr+(m*ngauss*ncomp)+n));
1393          else
1394            printf(" %d ",*(vale+(m*ngauss*ncomp)+n));
1395
1396      }
1397      break;
1398
1399        case MED_NO_INTERLACE :
1400      printf("\t- Valeurs :\n\t");
1401      for (m=0;m<ncomp;m++) {
1402        printf("|");
1403        for (n=0;n<nval;n++)
1404          if (typcha == MED_FLOAT64)
1405            printf(" %f ",*(valr+(m*nval)+n));
1406          else
1407            printf(" %d ",*(vale+(m*nval)+n));
1408      }
1409      break;
1410        }
1411
1412        printf("|\n");
1413        if (typcha == MED_FLOAT64) {
1414      if ( valr ) {free(valr);valr = NULL;}}
1415        else
1416      if (vale) { free(vale);vale = NULL; }
1417
1418        /*Lecture du profil associe */
1419        if (strcmp(pflname,MED_NOPFL) == 0 )
1420      printf("\t- Profil : MED_NOPFL\n");
1421        else {
1422
1423        if ( (pflsize = MEDnValProfil(fid,pflname)) <0 )  {
1424          MESSAGE("Erreur a la lecture du nombre de valeurs du profil : ");
1425          SSCRUTE(pflname);
1426          ret = -1; continue;
1427        }
1428
1429        printf("\t- Profil : |%s| de taille %i\n",pflname,pflsize);
1430
1431        pflval = (med_int*) malloc(sizeof(med_int)*pflsize);
1432        EXIT_IF(pflval == NULL,NULL,NULL);
1433        if ( MEDprofilLire(fid,pflval,pflname) <0) {
1434          MESSAGE("Erreur a la lecture des valeurs du profil : ");
1435          SSCRUTE(pflname);
1436          ret = -1;
1437        }
1438        printf("\t");
1439        for (m=0;m<pflsize;m++) printf(" %i ",*(pflval+m));
1440        printf("\n");
1441        free(pflval);
1442
1443      }
1444
1445        }
1446      }
1447    } /* fin for sur les mailles*/
1448
1449    return ret;
1450  }
1451
1452  /******************************************************************************
1453   * 
1454   * - Nom de la fonction : lecture_resultats
1455   * - Description : lecture et affichage des champs de resultats 
1456   *                 associe a un  maillage MED.
1457   * - Parametres :
1458   *     - fid                       (IN) : ID du fichier MED.
1459   *     - mdim                      (IN) : dimension du maillage.
1460   *     - mode_coo                  (IN) : mode de stockage en memoire : 
1461   *                                        MED_FULL_INTERLACE | MED_NO_INTERLACE.
1462   *     - lecture_en_tete_seulement (IN) : mode de lecture.
1463   *
1464   ******************************************************************************/
1465
1466  void lecture_resultats(med_idt fid,
1467                 med_mode_switch mode_coo,int lecture_en_tete_seulement)
1468  {
1469    med_err ret,lret;
1470    char pflname[MED_TAILLE_NOM+1]="",nomlien[MED_TAILLE_NOM+1]="";
1471    char * lien = NULL;
1472    char *comp, *unit;
1473    char nomcha  [MED_TAILLE_NOM+1]="";
1474    char locname[MED_TAILLE_NOM+1]="";
1475    med_int mdim,ncomp,ncha,npro,nln,pflsize,*pflval,nval,nloc,ngauss;
1476    med_type_champ typcha;
1477    med_maillage type;
1478    int t1,t2,t3;
1479    med_geometrie_element type_geo;
1480    med_float *refcoo, *gscoo, *wg;
1481    int i,j;
1482
1483    if (! lecture_en_tete_seulement) {
1484      fprintf(stdout,"\n(************************)\n");
1485      fprintf(stdout,"(* CHAMPS DU MAILLAGE : *)\n");
1486      fprintf(stdout,"(************************)\n");
1487    }
1488
1489    /* combien de champs dans le fichier */
1490    ncha = MEDnChamp(fid,0);
1491    EXIT_IF(ncha < 0,"lors de la lecture du nombre de champs",NULL);
1492    fprintf(stdout,"- Nombre de champs : %d \n",ncha);
1493
1494    if (lecture_en_tete_seulement)
1495      return;
1496
1497    /****************************************************************************
1498    *                       LECTURE DES CHAMPS                                  *
1499    ****************************************************************************/
1500    ret = 0;
1501
1502    /* lecture de tous les champs  */
1503    for (i =0;i<ncha;i++) {
1504      lret = 0;
1505      printf("\nChamp numero : |%d| \n",i+1);
1506
1507      /* Lecture du nombre de composantes */
1508      if ((ncomp = MEDnChamp(fid,i+1)) < 0) {
1509        MESSAGE("Erreur à la lecture du nombre de composantes : "); ISCRUTE(ncomp);
1510        ret = -1; continue;
1511      }
1512
1513      /* Lecture du type du champ, des noms des composantes et du nom de l'unité*/
1514      comp = (char*) malloc(ncomp*MED_TAILLE_PNOM+1);
1515      EXIT_IF(comp == NULL,NULL,NULL);
1516      unit = (char*) malloc(ncomp*MED_TAILLE_PNOM+1);
1517      EXIT_IF(unit == NULL,NULL,NULL);
1518
1519      if ( MEDchampInfo(fid,i+1,nomcha,&typcha,comp,unit,ncomp) < 0 ) {
1520        MESSAGE("Erreur à la demande d'information sur les champs : ");
1521        ret = -1; continue;
1522      }
1523
1524      printf("Nom du champ : |%s| de type |%d|\n",nomcha,typcha);
1525      printf("Nom des composantes : |%s|\n",comp);
1526      printf("Unites des composantes : |%s| \n",unit);
1527
1528      free(comp);
1529      free(unit);
1530
1531
1532      lret = getFieldsOn(fid, nomcha, typcha, ncomp, MED_NOEUD,mode_coo);
1533
1534      if (lret == 0) lret = getFieldsOn(fid, nomcha, typcha, ncomp, MED_MAILLE,mode_coo);
1535      else { MESSAGE("Erreur à la lecture des champs aux noeuds "); ret = -1; continue;}
1536
1537      if (lret == 0) lret = getFieldsOn(fid, nomcha, typcha, ncomp, MED_FACE,mode_coo);
1538      else { MESSAGE("Erreur à la lecture des champs aux mailles "); ret = -1; continue;}
1539
1540      if (lret == 0) lret = getFieldsOn(fid, nomcha, typcha, ncomp, MED_ARETE,mode_coo);
1541      else {MESSAGE("Erreur à la lecture des champs aux faces "); ret = -1; continue;}
1542
1543      if  (lret != 0) {MESSAGE("Erreur à la lecture des champs aux aretes "); ret = -1;};
1544    }
1545
1546
1547    /* Interrogation des profils */
1548    npro = MEDnProfil(fid);
1549
1550    printf("\nNombre de profils stockes : %i\n\n",npro);
1551    for (i=1 ; i <= npro ; i++ ) {
1552      if ( MEDprofilInfo(fid, i, pflname, &nval) < 0)  {
1553        MESSAGE("Erreur a la demande d'information sur le profil n° : "); ISCRUTE(i);
1554        ret = -1;continue;
1555      }
1556      printf("\t- Profil n°%i de nom |%s| et de taille %i\n",i,pflname,nval);
1557      pflval = (med_int*) malloc(sizeof(med_int)*nval);
1558      if ( MEDprofilLire(fid, pflval, pflname) < 0) {
1559        MESSAGE("Erreur a la lecture des valeurs du profil : ");
1560        SSCRUTE(pflname);
1561        ret = -1;
1562      } else {
1563        printf("\t");
1564        for (j=0;j<nval;j++) printf(" %i ",*(pflval+j));
1565        printf("\n\n");
1566      }
1567      free(pflval);
1568    }
1569
1570    /* Interrogation des liens */
1571    nln = MEDnLien(fid);
1572
1573    printf("\nNombre de liens stockes : %i\n\n",nln);
1574    for (i=1 ; i <= nln ; i++ ) {
1575      if ( MEDlienInfo(fid, i, nomlien, &nval) < 0)  {
1576        MESSAGE("Erreur a la demande d'information sur le lien n° : "); ISCRUTE(i);
1577        ret = -1;continue;
1578      }
1579      printf("\t- Lien n°%i de nom |%s| et de taille %i\n",i,nomlien,nval);
1580
1581      lien = malloc(nval*sizeof(char));
1582      EXIT_IF(lien == NULL,NULL,NULL);
1583
1584      if ( MEDlienLire(fid, lien, nomlien) < 0 )  {
1585        MESSAGE("Erreur a la lecture du lien : ");
1586        SSCRUTE(nomlien);SSCRUTE(lien);
1587        ret = -1;
1588      } else
1589        printf("\t\t|%s|\n\n",lien);
1590      free(lien);
1591    }
1592
1593    /* Interrogation des localisations des points de GAUSS */
1594    nloc = MEDnGauss(fid);
1595
1596    printf("\nNombre de localisations stockees : %i\n\n",nloc);
1597    for (i=1 ; i <= nloc ; i++ ) {
1598      if ( MEDgaussInfo(fid, i, locname, &type_geo, &ngauss) < 0)  {
1599        MESSAGE("Erreur a la demande d'information sur la localisation n° : "); ISCRUTE(i);
1600        ret = -1;continue;
1601      }
1602      printf("\t- Loc. n°%i de nom |%s| et nbr. de pts de GAUSS %i\n",i,locname,ngauss);
1603      t1 = (type_geo%100)*(type_geo/100);
1604      t2 = ngauss*(type_geo/100);
1605      t3 = ngauss;
1606      refcoo = (med_float *) malloc(sizeof(med_float)*t1 );
1607      gscoo  = (med_float *) malloc(sizeof(med_float)*t2 );
1608      wg     = (med_float *) malloc(sizeof(med_float)*t3 );
1609
1610      if ( MEDgaussLire(fid, refcoo, gscoo, wg, mode_coo, locname ) < 0) {
1611        MESSAGE("Erreur a la lecture des valeurs de la localisation : ");
1612        SSCRUTE(locname);
1613        ret = -1;
1614      } else {
1615        printf("\t  Coordonnees de l'element de reference de type %i :\n\t\t",type_geo);
1616        for (j=0;j<t1;j++) printf(" %f ",*(refcoo+j));
1617        printf("\n");
1618        printf("\t  Localisation des points de GAUSS : \n\t\t");
1619        for (j=0;j<t2;j++) printf(" %f ",*(gscoo+j));
1620        printf("\n");
1621        printf("\t  Poids associes aux points de GAUSS :\n\t\t");
1622        for (j=0;j<t3;j++) printf(" %f ",*(wg+j));
1623        printf("\n\n");
1624      }
1625      free(refcoo);
1626      free(gscoo);
1627      free(wg);
1628    }
1629
1630    return;
1631  }
1632
1633  /******************************************************************************
1634   *
1635   * - Nom de la fonction : lecture_parametres_scalaires
1636   * - Description : lecture des parametres scalaires definis
1637   *                 hors champs et maillages.
1638   * - Parametres :
1639   *     - fid                    (IN) : ID du fichier MED.
1640   *     - lecture_en_tete_seule  (IN) : mode de lecture.
1641   *
1642   ******************************************************************************/
1643
1644  void lecture_parametres_scalaires(med_idt fid,int lecture_en_tete_seulement)
1645  {
1646    med_err ret = 0;
1647    char nom_scalaire[MED_TAILLE_NOM+1];
1648    char description[MED_TAILLE_DESC+1];
1649    med_int vali;
1650    med_float valr;
1651    med_int i,n,npdt,j;
1652    med_type_champ type;
1653    med_int numdt,numo;
1654    med_float dt;
1655    char dt_unit[MED_TAILLE_PNOM+1];
1656
1657   fprintf(stdout,"\n(*******************************)\n");
1658   fprintf(stdout,"(* SCALAIRES HORS MODELE MED : *)\n");
1659   fprintf(stdout,"(*******************************)\n");
1660
1661    /* Combien de variables scalaire ? */
1662    n = MEDnScalaire(fid);
1663    EXIT_IF(n < 0,"lors de la lecture du nombre de scalaires",NULL);
1664    fprintf(stdout,"- Nombre de variables scalaires : %d\n",n);
1665
1666    if (lecture_en_tete_seulement)
1667      return ;
1668
1669    for (i=1;i<=n;i++) {
1670
1671      /* Lecture des infos (type,description) */
1672      ret = MEDscalaireInfo(fid,i,nom_scalaire,&type,description);
1673      EXIT_IF(ret < 0,"lors de la lecture des parametres d'un scalaire",NULL);
1674      printf("- Scalaire n°%d de nom %s \n",i,nom_scalaire);
1675      if (type == MED_FLOAT64)
1676        printf("  Type flottant. \n");
1677      else
1678        printf("  Type entier. \n");
1679      printf("  Description associee : [%s] \n",description);
1680
1681      /* Pour chaque scalaire on regarde les valeurs associees 
1682         eventuellement a des pas de temps et des numeros d'ordre */
1683      npdt = MEDnScalairePasdetemps(fid,nom_scalaire);
1684      EXIT_IF(npdt < 0,"lors de la lecture du nombre de pas de temps d'un scalaire",NULL);
1685      printf("   Nombre de valeurs stockees : %d \n",npdt);
1686
1687      for (j=1;j<=npdt;j++) {
1688        ret = MEDscalairePasdetempsInfo(fid,nom_scalaire,j,
1689                        &numdt,dt_unit,&dt,&numo);
1690        EXIT_IF(ret < 0,"lors de la lecture des parametres d'un pas de temps d'un scalaire",NULL);
1691
1692        if (numdt == MED_NOPDT)
1693      printf("   - Aucun de pas de temps \n");
1694        else
1695      printf("   - Pas de de temps de numero %d de valeur %f [%s] \n",numdt,dt,dt_unit);
1696        if (numo == MED_NONOR)
1697      printf("   - Aucun numero d'ordre \n");
1698        else
1699      printf("   - Numero d'ordre : %d \n",numo);
1700
1701        if (type == MED_FLOAT64)
1702      ret = MEDscalaireFlottantLire(fid,nom_scalaire,&valr,numdt,numo);
1703        else
1704      ret = MEDscalaireEntierLire(fid,nom_scalaire,&vali,numdt,numo);
1705        EXIT_IF(ret < 0,"lors de la lecture de la valeur d'un scalaire",NULL);
1706
1707      }
1708    }
1709
1710    return ;
1711  }
1712
1713
1714
1715  /******************************************************************************
1716   *
1717   * - Nom de la fonction : main
1718   * - Description : outil de DUMP d'un fichier MED.
1719   * - Parametres :
1720   *     - argc  (IN) : nombre d'arguments sur la ligne de commande.
1721   *     - argv  (IN) : liste des arguments.
1722   *
1723   ******************************************************************************/
1724
1725  int main (int argc, char **argv)
1726  {
1727    med_err ret = 0;
1728    int reponse;
1729    med_idt fid;
1730    int i;
1731    int numero;
1732    med_mode_switch mode_coo;
1733    med_connectivite typ_con;
1734    int lecture_en_tete_seulement = 0;
1735    char nom_universel[MED_TAILLE_LNOM+1];
1736    med_int long_fichier_en_tete;
1737    char *fichier_en_tete;
1738    char version_hdf[10];
1739    char version_med[10];
1740    med_int mdim,nmaa;
1741    /* nom du maillage */
1742    char nommaa[MED_TAILLE_NOM+1];
1743    char maillage_description[MED_TAILLE_DESC+1];
1744    med_maillage type_maillage;
1745    med_int edim;
1746    med_int majeur,mineur,release;
1747    med_int majeur_lu,mineur_lu,release_lu;
1748    med_int nprofils;
1749
1750
1751    /****************************************************************************
1752    *                  TEST DU NOMBRE D'ARGUMENTS                               *
1753    *                  argument 1 = nom du fichier MED                          *
1754    ****************************************************************************/
1755    EXIT_IF(argc != 2 && argc != 5,"nombre de parametres incorrects\n",NULL);
1756
1757    /****************************************************************************
1758    *                      OUVERTURE DU FICHIER EN LECTURE                      *
1759    ****************************************************************************/
1760
1761    /* on regarde s'il s'agit d'un fichier au format HDF 5 */
1762    ret = MEDformatConforme(argv[1]);
1763    EXIT_IF(ret < 0,"Le fichier n'est pas au format HDF V5 !!!",NULL);
1764
1765    /* Quelle version de MED est utilise par mdump ? */
1766    MEDversionDonner(&majeur,&mineur,&release);
1767    fprintf(stdout,"- Lecture du fichier à l'aide de la bibliothèque MED-fichier V%d.%d.%d \n",majeur,mineur,release);
1768
1769    fid = MEDouvrir(argv[1],MED_LECTURE);
1770    EXIT_IF( fid < 0,"ouverture du du fichier ",argv[1]);
1771
1772    /****************************************************************************
1773     *                     QUESTIONS PRELIMINAIRES                               *
1774     *    1. Mode d'affichage des coordonnees (entrelace ou non) ?               *
1775     *    2. Connectivite des elements (nodale ou descendante)                   *
1776     ****************************************************************************/
1777    fprintf(stdout,"\n >>>>>> DUMP DU FICHIER %s >>>>>>\n",argv[1]);
1778
1779    /* en-tete du fichier (presence optionnelle) */
1780    long_fichier_en_tete = MEDlFichDes(fid);
1781    if (long_fichier_en_tete > 0) {
1782      fichier_en_tete = (char *) malloc(sizeof(char)*(long_fichier_en_tete+1));
1783      EXIT_IF(fichier_en_tete == NULL,NULL,NULL);
1784
1785      /* on va lire dans le fichier */
1786      ret = MEDfichEntete(fid,MED_FICH_DES,fichier_en_tete);
1787      if (ret < 0)
1788        free(fichier_en_tete);
1789      EXIT_IF(ret < 0,"lecture de l'en-tete du fichier",argv[1]);
1790
1791      /* on affiche */
1792      fprintf(stdout,"- En-tete du fichier : %s \n",fichier_en_tete);
1793      free(fichier_en_tete);
1794    }
1795
1796    if (argc == 2) {
1797      fprintf(stdout,"(*****************)\n");
1798      fprintf(stdout,"(* PARAMETRAGE : *)\n");
1799      fprintf(stdout,"(*****************)\n");
1800      fprintf(stdout,"- Mode d'affichage des coordonnées des noeuds ? \n");
1801      fprintf(stdout,"  1. Mode entrelacé : taper 1 \n");
1802      fprintf(stdout,"  2. Mode non entrelacé : taper 2 \n");
1803      reponse = 0;
1804      do {
1805        fprintf(stdout,"  Reponse : ");
1806        scanf("%d",&reponse);
1807      } while (reponse != 1 && reponse != 2);
1808      if (reponse == 1)
1809        mode_coo = MED_FULL_INTERLACE;
1810      else
1811        mode_coo = MED_NO_INTERLACE;
1812
1813      fprintf(stdout,"- Connectivité des éléments ? \n");
1814      fprintf(stdout,"  1. Nodale : taper 1 \n");
1815      fprintf(stdout,"  2. Descendante : taper 2 \n");
1816      reponse = 0;
1817      do {
1818        fprintf(stdout,"  Reponse : ");
1819        scanf("%d",&reponse);
1820      } while (reponse != 1 && reponse != 2);
1821      if (reponse == 1)
1822        typ_con = MED_NOD;
1823      else
1824        typ_con = MED_DESC;
1825    }
1826    else {
1827      if (! strcmp(argv[3],"NODALE"))
1828        typ_con = MED_NOD;
1829      if (! strcmp(argv[3],"DESCENDANTE"))
1830        typ_con = MED_DESC;
1831
1832      if (!strcmp(argv[4],"NO_INTERLACE"))
1833        mode_coo = MED_NO_INTERLACE;
1834      if (!strcmp(argv[4],"FULL_INTERLACE"))
1835        mode_coo = MED_FULL_INTERLACE;
1836      if (! strcmp(argv[4],"LECTURE_EN_TETE_SEULEMENT"))
1837        lecture_en_tete_seulement = 1;
1838
1839    }
1840
1841    /****************************************************************************
1842    *                      QUEL MAILLAGE LIRE                                   *
1843    ****************************************************************************/
1844    nmaa = MEDnMaa(fid);
1845    EXIT_IF(nmaa < 0,"lors de la lecture du nombre de maillages",NULL);
1846
1847    /* Quel maillage lire ? */
1848    if (argc == 2) {
1849      fprintf(stdout,"- Il y a %d maillages dans ce fichier \n",nmaa);
1850      fprintf(stdout,"  Lequel voulez-vous lire (1|2|3|...|n) ?\n");
1851      do {
1852        fprintf(stdout,"  Reponse : ");
1853        scanf("%d",&numero);
1854      } while (numero > nmaa || numero <= 0);
1855    }
1856    else {
1857      numero = atoi(argv[2]);
1858      EXIT_IF(numero > nmaa || numero <= 0,"ce numero de maillage n'existe pas",NULL);
1859    }
1860
1861    /****************************************************************************
1862     *                       PARAMETRES SCALAIRES HORS MODELE MED               *
1863     ****************************************************************************/
1864
1865    /* on va lire l'ensemble des parametres scalaire */
1866    lecture_parametres_scalaires(fid,lecture_en_tete_seulement);
1867
1868    /****************************************************************************
1869     *                       INFOS GENERALES SUR LE MAILLAGE                    *
1870     ****************************************************************************/
1871    fprintf(stdout,"\n(********************************************)\n");
1872    fprintf(stdout,"(* INFORMATIONS GENERALES SUR LE MAILLAGE : *)\n");
1873    fprintf(stdout,"(********************************************)\n");
1874
1875    /* lecture du nom et de la dimension du maillage */
1876    ret = MEDmaaInfo(fid,numero,nommaa,&mdim,&type_maillage,maillage_description);
1877    EXIT_IF(ret < 0,"Lecture des informations sur le maillage",NULL);
1878    edim = MEDdimEspaceLire(fid,nommaa);
1879    fprintf(stdout,"- Nom du maillage : <<%s>>\n",nommaa);
1880    fprintf(stdout,"- Dimension du maillage : %d\n",mdim);
1881    if (edim > mdim)
1882      fprintf(stdout,"- La dimension de l'espace est %d \n",edim);
1883    if (type_maillage == MED_NON_STRUCTURE)
1884      fprintf(stdout,"- Type du maillage : MED_NON_STRUCTURE \n");
1885    else
1886      fprintf(stdout,"- Type du maillage : MED_STRUCTURE \n");
1887    fprintf(stdout,"- Description associee au maillage : %s\n",maillage_description);
1888
1889    /* lecture du nom universel (presence optionnelle) */
1890   ret = MEDunvLire(fid,nommaa,nom_universel);
1891   if (ret == 0)
1892     fprintf(stdout,"- Nom universel du maillage : %s \n",nom_universel);
1893   else
1894     fprintf(stdout,"- Pas de nom universel \n");
1895
1896
1897   /****************************************************************************
1898    *                      LECTURE DU MAILLAGE ET DES RESULTATS ASSOCIES        *
1899    ****************************************************************************/
1900
1901   /* en fonction du type du maillage */
1902   if (type_maillage == MED_NON_STRUCTURE)
1903     lecture_maillage_non_structure(fid,nommaa,mdim,mode_coo,typ_con,
1904                    lecture_en_tete_seulement);
1905   else
1906     lecture_maillage_structure(fid,nommaa,mdim,mode_coo,
1907                    lecture_en_tete_seulement);
1908
1909   /* on lit ensuite les resultats */
1910   lecture_resultats(fid,mode_coo,lecture_en_tete_seulement);
1911
1912   /****************************************************************************
1913   *                      FERMETURE DU FICHIER                                 *
1914   ****************************************************************************/
1915   ret = MEDfermer(fid);
1916   EXIT_IF(ret < 0,"lors de la fermeture du fichier",argv[1]);
1917
1918   fprintf(stdout,"\n >>>>>> FIN DU DUMP DU FICHIER %s >>>>>>\n",argv[1]);
1919
1920   return EXIT_SUCCESS;
1921  }