    /****************************************************************************
    * COPYRIGHT (C) 1999 - 2003  EDF R&D
    * THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
    * IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE
    * AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION;
    * EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
    *
    * THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
    * WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
    * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
    * LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
    *
    * YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
    * ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
    * INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
    *
    ******************************************************************************/

    /******************************************************************************
     * - Nom du fichier : mdump.c
     *
     * - Description : utilitaire de dump pour fichier MED V2.2
     *                 Ce fichier contient les fonctions suivantes
     *                 qui constituent des modeles de programmation
     *                 pour une lecture generique d'un fichier MED V2.2 :
     *                 - lecture_maillage_non_structure () :
     *                        1. Noeuds.
     *                        2. Mailles :
     *                           - APPORT V2.2 : polyedres et polygones.
     *                        3. Faces (connectivite descendante) :
     *                           - APPORT V2.2 : polygones.
     *                        4. Aretes (connectivite descendante).
     *                        5. Familles.
     *                        6. Equivalences.
     *                        7. Joints.
     *                 - lecture_maillage_structure ()     : (APPORT V2.2)
     *                        1. Grille cartesienne | polaire | destructuree
     *                        2. Familles de noeuds.
     *                 - lecture_resultats () :
     *                        1. Champs de resultats relatifs à un maillage.
     *                           - Entites :
     *                                - Noeuds
     *                                - Mailles
     *                                - Faces
     *                                - Aretes
     *                           - Gestion des pas de temps et numeros d'ordre :
     *                                - APPORT V2.2 : stockage des valeurs
     *                                  associees a plusieurs maillages sous
     *                                  un meme pas de temps.
     *                           - Gestion des profils.
     *                           - Gestion des liens vers des maillages distants
     *                                - APPORT V2.2.
     *                           - Gestion des points de Gauss :
     *                                - APPORT V2.2.: localisation des
     *                                  points de Gauss.
     *                 - lecture_parametres_scalaires () : (APPORT V2.2)
     *                           - Valeurs scalaires entieres ou flottantes.
     *                           - Gestion des pas de temps et numeros d'ordre.
     *                 - main() : infos generales + lecture de tous les champs et
     *                            du fichier MED passe en parametre.
     *
     *****************************************************************************/

    #include <med.h>
    #include <med_utils.h>
    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>

    #define USER_MODE MED_COMPACT

    /******************************************************************************
     *
     * - Nom de la fonction : lecture_maillage_non_structure
     * - Description : lecture et affichage d'un maillage MED_NON_STRUCTURE.
     * - Parametres :
     *     - fid                       (IN) : ID du fichier MED.
     *     - nommaa                    (IN) : nom du maillage a lire.
     *     - mdim                      (IN) : dimension du maillage.
     *     - mode_coo                  (IN) : mode de stockage en memoire :
     *                                        MED_FULL_INTERLACE | MED_NO_INTERLACE.
     *     - typ_con                   (IN) : mode de connectivite :
     *                                        MED_FULL_INTERLACE | MED_NO_INTERLACE.
     *     - lecture_en_tete_seulement (IN) : mode de lecture.
     *
     ******************************************************************************/

    /* nombre de mailles concernees par les equivalences */
    #define NBR_MAILLE_EQU  7

    void lecture_maillage_non_structure(med_idt fid,char *nommaa,med_int mdim,
                                        med_mode_switch mode_coo,
                                        med_connectivite typ_con,
                                        int lecture_en_tete_seulement)
    {
      med_err ret = 0;
      int i,j,k,l;
      /* nombre d'objets MED */
      med_int nnoe;
      med_int nmai[MED_NBR_GEOMETRIE_MAILLE],nfac[MED_NBR_GEOMETRIE_FACE];
      med_int nare[MED_NBR_GEOMETRIE_ARETE];
      /* noeuds */
      med_float *coo;
      char nomcoo[3*MED_TAILLE_PNOM+1];
      char unicoo[3*MED_TAILLE_PNOM+1];
      char *nomnoe;
      med_int *numnoe;
      med_int *nufano;
      med_repere rep;
      med_booleen inonoe,inunoe;
      char str[MED_TAILLE_PNOM+1];
      /* elements */
      med_int edim;
      med_int taille;
      med_int *connectivite;
      char *nomele;
      med_int *numele;
      med_int *nufael;
      med_booleen inoele, inuele;
      med_geometrie_element typgeo;
      med_geometrie_element typmai[MED_NBR_GEOMETRIE_MAILLE] =
                                                      {MED_POINT1,MED_SEG2,
                                                       MED_SEG3,MED_TRIA3,
                                                       MED_TRIA6,MED_QUAD4,
                                                       MED_QUAD8,MED_TETRA4,
                                                       MED_TETRA10,MED_HEXA8,
                                                       MED_HEXA20,MED_PENTA6,
                                                       MED_PENTA15,MED_PYRA5,
                                                       MED_PYRA13};
      med_int desmai[MED_NBR_GEOMETRIE_MAILLE] = {0,2,3,3,3,4,4,4,4,6,6,5,5,5,5};
      med_int nmailles[MED_NBR_GEOMETRIE_MAILLE];
      char nommai[MED_NBR_GEOMETRIE_MAILLE] [MED_TAILLE_NOM+1] = {"MED_POINT1",
                                                              "MED_SEG2",
                                                              "MED_SEG3",
                                                              "MED_TRIA3",
                                                              "MED_TRIA6",
                                                              "MED_QUAD4",
                                                              "MED_QUAD8",
                                                              "MED_TETRA4",
                                                              "MED_TETRA10",
                                                              "MED_HEXA8",
                                                              "MED_HEXA20",
                                                              "MED_PENTA6",
                                                              "MED_PENTA15",
                                                              "MED_PYRA5",
                                                              "MED_PYRA13"};
      med_geometrie_element typfac[MED_NBR_GEOMETRIE_FACE] = {MED_TRIA3,MED_TRIA6,
                                                              MED_QUAD4,MED_QUAD8};
      med_int desfac[MED_NBR_GEOMETRIE_FACE] = {3,3,4,4};
      med_int nfaces[MED_NBR_GEOMETRIE_FACE];
      char nomfac[MED_NBR_GEOMETRIE_FACE][MED_TAILLE_NOM+1] = {"MED_TRIA3",
                                                               "MED_TRIA6",
                                                               "MED_QUAD4",
                                                               "MED_QUAD8"};
      med_geometrie_element typare[MED_NBR_GEOMETRIE_ARETE] = {MED_SEG2,
                                                               MED_SEG3};
      med_int desare[MED_NBR_GEOMETRIE_ARETE] = {2,3};
      med_int naretes[MED_NBR_GEOMETRIE_ARETE];
      char nomare[MED_NBR_GEOMETRIE_ARETE] [MED_TAILLE_NOM+1] = {"MED_SEG2",
                                                                 "MED_SEG3"};
      /* familles */
      med_int nfam;
      med_int natt,ngro;
      char *attdes,*gro;
      med_int *attval,*attide;
      char nomfam[MED_TAILLE_NOM+1];
      med_int numfam;
      char str1[MED_TAILLE_DESC+1];
      char str2[MED_TAILLE_LNOM+1];

      /* equivalences */
      med_int nequ,ncor;
      med_int *cor;
      char equ[MED_TAILLE_NOM+1];
      char des[MED_TAILLE_DESC+1];

      /* joints */
      med_int njnt,ndom,nc,nent;
      med_int typ_ent_local,typ_geo_local,typ_ent_distant,typ_geo_distant;
      med_int geo_ent_local,geo_ent_distant;

      char jn[MED_TAILLE_NOM+1];
      char maa_dist[MED_TAILLE_NOM+1];
      char corr[MED_TAILLE_NOM+1];
      med_int *cortab;

      const med_int nb_geo_ent=1+MED_NBR_GEOMETRIE_MAILLE+MED_NBR_GEOMETRIE_ARETE+MED_NBR_GEOMETRIE_FACE;
      med_geometrie_element typ_geo_ent[1+MED_NBR_GEOMETRIE_MAILLE+MED_NBR_GEOMETRIE_ARETE+MED_NBR_GEOMETRIE_FACE][2]=
        {
          {MED_NOEUD,0},
          {MED_MAILLE,MED_POINT1   },
          {MED_MAILLE,MED_SEG2     },
          {MED_MAILLE,MED_SEG3     },
          {MED_MAILLE,MED_TRIA3    },
          {MED_MAILLE,MED_TRIA6    },
          {MED_MAILLE,MED_QUAD4    },
          {MED_MAILLE,MED_QUAD8    },
          {MED_MAILLE,MED_TETRA4   },
          {MED_MAILLE,MED_TETRA10  },
          {MED_MAILLE,MED_HEXA8    },
          {MED_MAILLE,MED_HEXA20   },
          {MED_MAILLE,MED_PENTA6   },
          {MED_MAILLE,MED_PENTA15  },
          {MED_MAILLE,MED_PYRA5    },
          {MED_MAILLE,MED_PYRA13   },
          {MED_ARETE ,MED_SEG2     },
          {MED_ARETE ,MED_SEG3     },
          {MED_FACE  ,MED_TRIA3    },
          {MED_FACE  ,MED_TRIA6    },
          {MED_FACE  ,MED_QUAD4    },
          {MED_FACE  ,MED_QUAD8    }
        };
      char nom_geo_ent[1+MED_NBR_GEOMETRIE_MAILLE+MED_NBR_GEOMETRIE_ARETE+MED_NBR_GEOMETRIE_FACE][MED_TAILLE_NOM+1] =
        {
          "MED_NOEUD           ",
          "MED_MAILLE:MED_POINT1   ",
          "MED_MAILLE:MED_SEG2     ",
          "MED_MAILLE:MED_SEG3     ",
          "MED_MAILLE:MED_TRIA3    ",
          "MED_MAILLE:MED_TRIA6    ",
          "MED_MAILLE:MED_QUAD4    ",
          "MED_MAILLE:MED_QUAD8    ",
          "MED_MAILLE:MED_TETRA4   ",
          "MED_MAILLE:MED_TETRA10  ",
          "MED_MAILLE:MED_HEXA8    ",
          "MED_MAILLE:MED_HEXA20   ",
          "MED_MAILLE:MED_PENTA6   ",
          "MED_MAILLE:MED_PENTA15  ",
          "MED_MAILLE:MED_PYRA5    ",
          "MED_MAILLE:MED_PYRA13   ",
          "MED_ARETE :MED_SEG2     ",
          "MED_ARETE :MED_SEG3     ",
          "MED_FACE  :MED_TRIA3    ",
          "MED_FACE  :MED_TRIA6    ",
          "MED_FACE  :MED_QUAD4    ",
          "med_FACE  :MED_QUAD8    "
        };

      /* mailles/faces MED_POLYGONE et MED_POLYEDRE */
      med_int nmpolygones,nfpolygones,npolyedres;
      med_int *indexp, *indexf;
      int ind1,ind2,np;
      med_int nf;
      char tmp[MED_TAILLE_NOM+1];
      med_err ret1,ret2,ret3;
      med_int nfa;

      /* Combien de noeuds ? */
      nnoe = MEDnEntMaa(fid,nommaa,MED_COOR,MED_NOEUD,0,0);
      EXIT_IF(nnoe < 0,"lors de la lecture du nombre de noeuds",NULL);
      fprintf(stdout,"- Nombre de noeuds : %d \n",nnoe);

      /* Combien de mailles, faces ou aretes ? */
      for (i=0;i<MED_NBR_GEOMETRIE_MAILLE;i++) {
        nmailles[i] = MEDnEntMaa(fid,nommaa,MED_CONN,MED_MAILLE,typmai[i],
                                 typ_con);
        EXIT_IF(nmailles[i] < 0," lors de la lecture du nombre de mailles",NULL);
        fprintf (stdout,"- Nombre de mailles de type %s : %d \n",nommai[i],nmailles[i]);
      }

      /* Combien de mailles polygones  ? */
      nmpolygones = MEDnEntMaa(fid,nommaa,MED_CONN,MED_MAILLE,MED_POLYGONE,
                               typ_con);
      EXIT_IF(nmpolygones < 0,"lors de la lecture du nombre de mailles polygone \n",
              NULL);
      fprintf(stdout,"- Nombre de mailles de type MED_POLYGONE : %d \n",nmpolygones);

      /* Combien de mailles polyedres ? */
      npolyedres = MEDnEntMaa(fid,nommaa,MED_CONN,MED_MAILLE,MED_POLYEDRE,
                              typ_con);
      EXIT_IF(npolyedres < 0,"lors de la lecture du nombre de mailles polyedre \n",
              NULL);
      fprintf(stdout,"- Nombre de mailles de type MED_POLYEDRE : %d \n",npolyedres);

      /* Combien de faces ? */
      for (i=0;i<MED_NBR_GEOMETRIE_FACE;i++) {
        nfaces[i] = MEDnEntMaa(fid,nommaa,MED_CONN,MED_FACE,typfac[i],
                               typ_con);
        EXIT_IF(nfaces[i] < 0,"lors de la lecture du nombre de faces",NULL);
          fprintf (stdout,"- Nombre de faces de type %s : %d \n",nomfac[i],nfaces[i]);
      }

      /* Combien de faces polygones  ? */
      nfpolygones = MEDnEntMaa(fid,nommaa,MED_CONN,MED_FACE,MED_POLYGONE,
                               typ_con);
      EXIT_IF(nfpolygones < 0,"lors de la lecture du nombre de faces polygone \n",
              NULL);
      fprintf(stdout,"- Nombre de faces de type MED_POLYGONE : %d \n",nfpolygones);

      /* Combien d'aretes */
      for (i=0;i<MED_NBR_GEOMETRIE_ARETE;i++) {
        naretes[i] = MEDnEntMaa(fid,nommaa,MED_CONN,MED_ARETE,typare[i],
                                typ_con);
        EXIT_IF(naretes[i] < 0,"lors de la lecture du nombre d'aretes",NULL);
        fprintf (stdout,"- Nombre d'aretes de type %s : %d \n",nomare[i],naretes[i]);
      }

      /* nombre de familles */
      nfam = MEDnFam(fid,nommaa);
      EXIT_IF(nfam < 0,"lors de la lecture du nombre de familles",NULL);
      fprintf(stdout,"- Nombre de familles : %d \n",nfam);

      /* combien d'equivalences dans le fichier */
      nequ = MEDnEquiv(fid,nommaa);
      EXIT_IF(nequ < 0,"lors de la lecture du nombre d'equivalences",NULL);
      fprintf(stdout,"- Nombre d'equivalences : %d \n",nequ);

      /* combien de joints dans le fichier */
      njnt = MEDnJoint(fid,nommaa);
      EXIT_IF(njnt < 0,"lors de la lecture du nombre de joints",NULL);
      fprintf(stdout,"- Nombre de joints : %d \n",njnt);

      /* en fonction du mode de lecture, on continue ou non */
      if (lecture_en_tete_seulement)
        return;

      /****************************************************************************
      *                       LECTURE DES NOEUDS                                  *
      ****************************************************************************/

      /* Allocations memoires */
      /* table des coordonnees
         profil : (dimension * nombre de noeuds ) */
      coo = (med_float*) malloc(sizeof(med_float)*nnoe*mdim);
      EXIT_IF(coo == NULL,NULL,NULL);
      /* table  des numeros, des numeros de familles des noeuds
         profil : (nombre de noeuds) */
      numnoe = (med_int*) malloc(sizeof(med_int)*nnoe);
      EXIT_IF(numnoe == NULL,NULL,NULL);
      nufano = (med_int*) malloc(sizeof(med_int)*nnoe);
      EXIT_IF(nufano == NULL,NULL,NULL);
      /* table des noms des noeuds
         profil : (nnoe*MED_TAILLE_PNOM+1) */
      nomnoe = (char*) malloc(MED_TAILLE_PNOM*nnoe+1);
      EXIT_IF(nomnoe == NULL,NULL,NULL);

      /* lecture des noeuds :
         - coordonnees
         - noms (optionnel dans un fichier MED)
         - numeros (optionnel dans un fichier MED)
         - numeros des familles */
      ret = MEDnoeudsLire(fid,nommaa,mdim,coo,mode_coo,&rep,
                          nomcoo,unicoo,nomnoe,&inonoe,numnoe,&inunoe,
                          nufano,nnoe);
      EXIT_IF(ret < 0,"lors de la lecture des noeuds du maillage \n",NULL);

      /* affichage des resultats */
      fprintf(stdout,"\n(************************)\n");
      fprintf(stdout,"(* NOEUDS DU MAILLAGE : *)\n");
      fprintf(stdout,"(************************)\n");
      fprintf(stdout,"- Type de repere des coordonnees : %d \n",rep);
      fprintf(stdout,"- Nom des coordonnees : \n");
      for (i=0;i<mdim;i++) {
        strncpy(str,nomcoo+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
        str[MED_TAILLE_PNOM] = '\0';
        fprintf(stdout," %s ",str);
      }
      fprintf(stdout,"\n- Unites des coordonnees : \n");
      for (i=0;i<mdim;i++) {
        strncpy(str,unicoo+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
        str[MED_TAILLE_PNOM] = '\0';
        fprintf(stdout," %s ",str);
      }
      fprintf(stdout,"\n- Coordonnees des noeuds : \n");
      for (i=0;i<nnoe*mdim;i++)
        fprintf(stdout," %f ",*(coo+i));
      if (inonoe) {
        fprintf(stdout,"\n- Noms des noeuds : \n");
        for (i=0;i<nnoe;i++) {
          strncpy(str,nomnoe+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
          str[MED_TAILLE_PNOM] = '\0';
          fprintf(stdout," %s ",str);
        }
      }
      if (inunoe) {
        fprintf(stdout,"\n- Numeros des noeuds : \n");
        for (i=0;i<nnoe;i++)
          fprintf(stdout," %d ",*(numnoe+i));
      }
      fprintf(stdout,"\n- Numeros des familles des noeuds : \n");
      for (i=0;i<nnoe;i++)
        fprintf(stdout," %d ",*(nufano+i));
      fprintf(stdout,"\n");

      /* liberation memoire */
      free(coo);
      free(nomnoe);
      free(numnoe);
      free(nufano);

      /****************************************************************************
      *                       LECTURE DES ELEMENTS                                *
      ****************************************************************************/

      fprintf(stdout,"\n(**************************)\n");
      fprintf(stdout,"(* ELEMENTS DU MAILLAGE : *)\n");
      fprintf(stdout,"(**************************)");

      /* Lecture des connectivites, noms, numeros des mailles */
      for (i=0;i<MED_NBR_GEOMETRIE_MAILLE;i++)
        if (nmailles[i] > 0) {

          /* dimension de la maille */
          edim = typmai[i] / 100;
          switch(typ_con) {
          case MED_NOD :
            taille = typmai[i]%100;
            break;

          case MED_DESC :
            taille = desmai[i];
            break;

          default :
            ret = -1;
          }

          /* allocation memoire */
          connectivite = (med_int*)malloc(sizeof(med_int)*taille*nmailles[i]);
          EXIT_IF(connectivite == NULL,NULL,NULL);
          nomele = (char*)malloc(sizeof(char)*MED_TAILLE_PNOM*nmailles[i]+1);
          EXIT_IF(nomele == NULL,NULL,NULL);
          numele = (med_int*)malloc(sizeof(med_int)*nmailles[i]);
          EXIT_IF(numele == NULL,NULL,NULL);
          nufael = (med_int*)malloc(sizeof(med_int)*nmailles[i]);
          EXIT_IF(nufael == NULL,NULL,NULL);

          /* lecture des données */
          ret = MEDelementsLire(fid,nommaa,mdim,connectivite,mode_coo,
                                  nomele,&inoele,numele,&inuele,nufael,
                                nmailles[i],MED_MAILLE,typmai[i],
                                typ_con);
          EXIT_IF(ret < 0,"lors de la lecture des mailles (conncetivite,numeros,noms et numeros de famille",
                  NULL);

          /* affichage des resultats */
          fprintf(stdout,"\n\n- Mailles de type %s : ", nommai[i]);
          fprintf(stdout,"\n  - Connectivité : \n");
          for (j=0;j<nmailles[i]*taille;j++)
            fprintf(stdout," %d ",*(connectivite+j));
          if (inoele) {
            fprintf(stdout,"\n  - Noms : \n");
            for (j=0;j<nmailles[i];j++) {
              strncpy(str,nomele+j*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
              str[MED_TAILLE_PNOM] = '\0';
              fprintf(stdout," %s ",str);
            }
          }
          if (inuele) {
            fprintf(stdout,"\n  - Numeros :\n");
            for (j=0;j<nmailles[i];j++)
              fprintf(stdout," %d ",*(numele+j));
          }
          fprintf(stdout,"\n  - Numéros de familles : \n");
          for (j=0;j<nmailles[i];j++)
            fprintf(stdout," %d ",*(nufael+j));

          /* liberation memoire */
          free(connectivite);
          free(nomele);
          free(numele);
          free(nufael);
        }

      /* lecture des mailles de type MED_POLYGONE */
      if (nmpolygones > 0) {

        /* quelle taille pour  le tableau des connectivites ? */
        ret = MEDpolygoneInfo(fid,nommaa,MED_MAILLE,typ_con,&taille);
        EXIT_IF(ret < 0,"lors de la lecture des parametres des mailles MED_POLYGONE",NULL);

        /* allocation memoire */
        indexp = (med_int *) malloc(sizeof(med_int)*(nmpolygones+1));
        EXIT_IF(indexp == NULL,NULL,NULL);
        connectivite = (med_int *) malloc(sizeof(med_int)*taille);
        EXIT_IF(connectivite == NULL,NULL,NULL);
        numele = (med_int *) malloc(sizeof(med_int)*nmpolygones);
        EXIT_IF(numele == NULL,NULL,NULL);
        nufael = (med_int *) malloc(sizeof(med_int)*nmpolygones);
        EXIT_IF(nufael == NULL,NULL,NULL);
        nomele = (char *) malloc(sizeof(char)*MED_TAILLE_PNOM*nmpolygones+1);
        EXIT_IF(nomele == NULL,NULL,NULL);

        /* lecture de la connectivite des mailles polygones */
        ret = MEDpolygoneConnLire(fid,nommaa,indexp,nmpolygones+1,connectivite,
                                  MED_MAILLE,typ_con);
        EXIT_IF(ret < 0,"lors de la lecture des connectivites des mailles de type MED_POLYGONE",NULL);

        /* lecture noms */
        ret1 = MEDnomLire(fid,nommaa,nomele,nmpolygones,MED_MAILLE,MED_POLYGONE);

        /* lecture des numeros */
        ret2 = (med_int) MEDnumLire(fid,nommaa,numele,nmpolygones,
                                    MED_MAILLE,MED_POLYGONE);

        /* lecture des numeros de familles */
        ret3 = MEDfamLire(fid,nommaa,nufael,nmpolygones,MED_MAILLE,MED_POLYGONE);
        if (ret3 < 0)
          for (i=0;i<nmpolygones;i++)
            *(nufael+i) = 0;

        /* affichage des resultats */
        fprintf(stdout,"\n\n- Mailles de type MED_POLYGONE : ");
        for (i=0;i<nmpolygones;i++) {
          fprintf(stdout,"\n >> Maille MED_POLYGONE %d : \n",i+1);
          fprintf(stdout,"\n  - Connectivité : ");
          ind1 = *(indexp+i)-1;
          ind2 = *(indexp+i+1)-1;
          for (j=ind1;j<ind2;j++)
            printf(" %d ",*(connectivite+j));
          if (ret1 == 0) {
            strncpy(tmp,nomele+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
            tmp[MED_TAILLE_PNOM] = '\0';
            fprintf(stdout,"\n  - Nom : %s \n",tmp);
          }
          if (ret2 == 0)
            fprintf(stdout,"\n  - Numero : %d \n",*(numele+i));
          fprintf(stdout,"\n  - Numéro de famille : %d \n",*(nufael+i));
        }

        /* on libere la memoire */
        free(indexp);
        free(connectivite);
        free(numele);
        free(nufael);
        free(nomele);
      }

      /* lecture des mailles de type MED_POLYEDRE */
      if (npolyedres > 0) {

        /* lecture des parametres de base */
        ret = MEDpolyedreInfo(fid,nommaa,typ_con,&nf,&taille);
        EXIT_IF(ret < 0,"lors de la lecture des parametres des mailles MED_POLYEDRE",NULL);

        /* allocation memoire */
        indexp        = (med_int *) malloc(sizeof(med_int)*(npolyedres+1));
        EXIT_IF(indexp == NULL,NULL,NULL);
        indexf        = (med_int *) malloc(sizeof(med_int)*nf);
        EXIT_IF(indexf == NULL,NULL,NULL);
        connectivite  = (med_int *) malloc(sizeof(med_int)*taille);
        EXIT_IF(connectivite == NULL,NULL,NULL);
        numele        = (med_int *) malloc(sizeof(med_int)*npolyedres);
        EXIT_IF(numele == NULL,NULL,NULL);
        nufael        = (med_int *) malloc(sizeof(med_int)*npolyedres);
        EXIT_IF(nufael == NULL,NULL,NULL);
        nomele        = (char *) malloc(sizeof(char)*MED_TAILLE_PNOM*npolyedres+1);
        EXIT_IF(nomele == NULL,NULL,NULL);

        /* lecture de la connectivite des mailles polyedres */
        ret = MEDpolyedreConnLire(fid,nommaa,indexp,npolyedres+1,indexf,nf,
                                  connectivite,MED_NOD);
        EXIT_IF(ret < 0,"lors de la lecture de la connectivite des mailles MED_POLYEDRES",
                NULL);

        /* lecture des noms */
        ret1 = MEDnomLire(fid,nommaa,nomele,npolyedres,MED_MAILLE,MED_POLYEDRE);

        /* lecture des numeros */
        ret2 = MEDnumLire(fid,nommaa,numele,npolyedres,MED_MAILLE,MED_POLYEDRE);

        /* lecture des numeros de familles */
        ret3 = MEDfamLire(fid,nommaa,nufael,npolyedres,MED_MAILLE,MED_POLYEDRE);
        if (ret3 < 0)
          for (i=0;i<npolyedres;i++)
            *(nufael+i) = 0;

        /* affichage des resultats */
        fprintf(stdout,"\n\n- Mailles de type MED_POLYEDRE : ");
        for (i=0;i<npolyedres;i++) {
          fprintf(stdout,"\n >> Maille MED_POLYEDRE %d : \n",i+1);
          fprintf(stdout,"\n  - Connectivité : \n");
          nfa  = *(indexp+i+1) - *(indexp+i);
          /* ind1 = indice dans "indexf" pour acceder aux numeros des faces */
          ind1 = *(indexp+i) - 1;
          for (j=0;j<nfa;j++) {
            if (typ_con == MED_NOD) {
              /* ind2 = indice dans "connectivite"
                 pour acceder au premier noeud de la face */
              ind2 = *(indexf+ind1+j) - 1;
              nnoe = *(indexf+ind1+j+1) - *(indexf+ind1+j);
              fprintf(stdout,"   - Face %d : [ ", j+1);
              for (k=0;k<nnoe;k++)
                printf(" %d ",*(connectivite+ind2+k));
              printf(" ] \n");
            }
            else {
              nfa  = *(indexp+i+1) - *(indexp+i);
              /* ind1 = indice dans "connectivite"
                 pour acceder aux numeros des faces */
              ind1 = *(indexp+i) - 1;
              for (j=0;j<nfa;j++)
                fprintf(stdout,"   - Face %d de numero : %d et de type %d \n", j+1,
                        *(connectivite+ind1+j),*(indexf+ind1+j));
            }
          }
          if (ret1 == 0) {
            strncpy(tmp,nomele+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
            tmp[MED_TAILLE_PNOM] = '\0';
            fprintf(stdout,"\n  - Nom : %s \n",tmp);
          }
          if (ret2 == 0)
            fprintf(stdout,"\n  - Numero : %d \n",*(numele+i));
          fprintf(stdout,"\n  - Numéro de famille : %d \n",*(nufael+i));
        }

        /* on libere la memoire */
        free(indexp);
        free(indexf);
        free(connectivite);
        free(numele);
        free(nufael);
        free(nomele);

      }

      /* lecture des faces */
      if (typ_con == MED_DESC)
        for (i=0;i<MED_NBR_GEOMETRIE_FACE;i++)
          if (nfaces[i] > 0 ) {

            /* dimension de la face */
            edim = typfac[i] / 100;
            switch(typ_con) {
            case MED_NOD :
              taille = typfac[i]%100;
              break;

            case MED_DESC :
              taille = desfac[i];
              break;

            default :
              ret = -1;
            }

            /* allocation memoire */
            connectivite = (med_int*)malloc(sizeof(med_int)*taille*nfaces[i]);
            EXIT_IF(connectivite == NULL,NULL,NULL);
            nomele = (char*)malloc(sizeof(char)*MED_TAILLE_PNOM*nfaces[i]+1);
            EXIT_IF(nomele == NULL,NULL,NULL);
            numele = (med_int*)malloc(sizeof(med_int)*nfaces[i]);
            EXIT_IF(numele == NULL,NULL,NULL);
            nufael = (med_int*)malloc(sizeof(med_int)*nfaces[i]);
            EXIT_IF(nufael == NULL,NULL,NULL);

            /* lecture des données */
            ret = MEDelementsLire(fid,nommaa,mdim,connectivite,mode_coo,
                                  nomele,&inoele,numele,&inuele,nufael,
                                  nfaces[i],MED_FACE,typfac[i],
                                  typ_con);
            EXIT_IF(ret < 0,"lors de la lecture des faces (connectivite,noms,numeros,numeros de familles)",
                    NULL);

            /* affichage des resultats */
            fprintf(stdout,"\n- Faces de type %s : ", nomfac[i]);
            fprintf(stdout,"\n  - Connectivité : \n");
            for (j=0;j<nfaces[i]*taille;j++)
              fprintf(stdout," %d ",*(connectivite+j));
            if (inoele) {
              fprintf(stdout,"\n  - Noms : \n");
              for (j=0;j<nfaces[i];j++) {
                fprintf(stdout," %d ",*(connectivite+j));
                strncpy(str,nomele+j*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
                str[MED_TAILLE_PNOM] = '\0';
                fprintf(stdout," %s ",str);
              }
            }
            if (inuele) {
              fprintf(stdout,"\n  - Numeros :\n");
              for (j=0;j<nfaces[i];j++)
                fprintf(stdout," %d ",*(numele+j));
            }
            fprintf(stdout,"\n  - Numéros de familles : \n");
            for (j=0;j<nfaces[i];j++)
              fprintf(stdout," %d ",*(nufael+j));

            /* liberation memoire */
            free(connectivite);
            free(nomele);
            free(numele);
            free(nufael);
          }

      /* lecture des faces de type MED_POLYGONE */
      if (nfpolygones > 0 && typ_con == MED_DESC) {

        /* quelle taille pour  le tableau des connectivites ? */
        ret = MEDpolygoneInfo(fid,nommaa,MED_FACE,typ_con,&taille);
        EXIT_IF(ret < 0,"lors de la lecture des parametres des faces MED_POLYGONE",NULL);

        /* allocation memoire */
        indexp = (med_int *) malloc(sizeof(med_int)*(nfpolygones+1));
        EXIT_IF(indexp == NULL,NULL,NULL);
        connectivite = (med_int *) malloc(sizeof(med_int)*taille);
        EXIT_IF(connectivite == NULL,NULL,NULL);
        numele = (med_int *) malloc(sizeof(med_int)*nfpolygones);
        EXIT_IF(numele == NULL,NULL,NULL);
        nufael = (med_int *) malloc(sizeof(med_int)*nfpolygones);
        EXIT_IF(nufael == NULL,NULL,NULL);
        nomele = (char *) malloc(sizeof(char)*MED_TAILLE_PNOM*nfpolygones+1);
        EXIT_IF(nomele == NULL,NULL,NULL);

        /* lecture de la connectivite des faces polygones */
        ret = MEDpolygoneConnLire(fid,nommaa,indexp,nfpolygones+1,connectivite,
                                  MED_FACE,typ_con);
        EXIT_IF(ret < 0,"lors de la lecture des connectivites des faces de type MED_POLYGONE",NULL);

        /* lecture noms */
        ret1 = MEDnomLire(fid,nommaa,nomele,nfpolygones,MED_FACE,MED_POLYGONE);

        /* lecture des numeros */
        ret2 = (med_int) MEDnumLire(fid,nommaa,numele,nfpolygones,
                                    MED_FACE,MED_POLYGONE);

        /* lecture des numeros de familles */
        ret3 = MEDfamLire(fid,nommaa,nufael,nfpolygones,MED_FACE,MED_POLYGONE);
        if (ret3 < 0)
          for (i=0;i<nfpolygones;i++)
            *(nufael+i) = 0;

        /* affichage des resultats */
        fprintf(stdout,"\n\n- Faces de type MED_POLYGONE : ");
        for (i=0;i<nfpolygones;i++) {
          fprintf(stdout,"\n >> Face MED_POLYGONE %d : \n",i+1);
          fprintf(stdout,"\n  - Connectivité : ");
          ind1 = *(indexp+i)-1;
          ind2 = *(indexp+i+1)-1;
          for (j=ind1;j<ind2;j++)
            fprintf(stdout," %d ",*(connectivite+j));
          if (ret1 == 0) {
            strncpy(tmp,nomele+j*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
            tmp[MED_TAILLE_PNOM] = '\0';
            fprintf(stdout,"\n  - Nom : %s \n",tmp);
          }
          if (ret2 == 0)
            fprintf(stdout,"\n  - Numero : %d \n",*(numele+j));
          fprintf(stdout,"\n  - Numéro de famille : %d \n",*(nufael+j));
        }

        /* on libere la memoire */
        free(indexp);
        free(connectivite);
        free(numele);
        free(nufael);
        free(nomele);
      }

      /* les aretes */
      if (typ_con == MED_DESC)
        for (i=0;i<MED_NBR_GEOMETRIE_ARETE;i++)
          if (naretes[i] > 0) {

            /* dimension de l'arete  */
            edim = typare[i] / 100;
            switch(typ_con) {
            case MED_NOD :
              taille = typare[i]%100;
              break;

            case MED_DESC :
              taille = desare[i];
              break;

            default :
              ret = -1;
            }

            /* allocation memoire */
            connectivite = (med_int*)malloc(sizeof(med_int)*taille*naretes[i]);
            EXIT_IF(connectivite == NULL,NULL,NULL);
            nomele = (char*)malloc(sizeof(char)*MED_TAILLE_PNOM*naretes[i]+1);
            EXIT_IF(nomele == NULL,NULL,NULL);
            numele = (med_int*)malloc(sizeof(med_int)*naretes[i]);
            EXIT_IF(numele == NULL,NULL,NULL);
            nufael = (med_int*)malloc(sizeof(med_int)*naretes[i]);
            EXIT_IF(nufael == NULL,NULL,NULL);

            /* lecture des données */
            ret = MEDelementsLire(fid,nommaa,mdim,connectivite,mode_coo,
                                  nomele,&inoele,numele,&inuele,nufael,
                                  naretes[i],MED_ARETE,typare[i],
                                  typ_con);
            EXIT_IF(ret < 0,"lors de la lecture des aretes (connectivite,noms,numeros,numeros de familles)",
                    NULL);

            /* affichage des resultats */
            fprintf(stdout,"\n- Aretes de type %d : ", nomare[i]);
            fprintf(stdout,"\n  - Connectivité : \n");
            for (j=0;j<naretes[i]*taille;j++)
              fprintf(stdout," %d ",*(connectivite+j));
            if (inoele) {
              fprintf(stdout,"\n  - Noms : \n");
              for (j=0;j<naretes[i];j++) {
                fprintf(stdout," %d ",*(connectivite+j));
                strncpy(str,nomele+j*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
                str[MED_TAILLE_PNOM] = '\0';
                fprintf(stdout," %s ",str);
              }
            }
            if (inuele) {
              fprintf(stdout,"\n  - Numeros :\n");
              for (j=0;j<naretes[i];j++)
                fprintf(stdout," %d ",*(numele+j));
            }
            fprintf(stdout,"\n  - Numéros de familles : \n");
            for (j=0;j<naretes[i];j++)
              fprintf(stdout," %d ",*(nufael+j));

            /* liberation memoire */
            free(connectivite);
            free(nomele);
            free(numele);
            free(nufael);
          }

      /****************************************************************************
       *                       LECTURE DES FAMILLES                                *
       ****************************************************************************/
      printf("\n(*************************)\n");
      printf("(* FAMILLES DU MAILLAGE  *)\n");
      printf("(*************************)\n");

      for (i=0;i<nfam;i++) {

        /* nombre de groupes */
        ngro = MEDnGroupe(fid,nommaa,i+1);
        EXIT_IF(ngro < 0,"lors de la lecture du nombre de groupe d'une famille",NULL);

        /* nombre d'attributs */
        natt = MEDnAttribut(fid,nommaa,i+1);
        EXIT_IF(natt < 0,"lors de la lecture du nombre d'attributs d'une famille",NULL);

        fprintf(stdout,"- Famille %d a %d attribut(s) et %d groupe(s) \n",i+1,natt,ngro);

        /* nom,numero,attributs,groupes */

        /* allocation memoire */
        if (natt > 0) {
          attide = (med_int*) malloc(sizeof(med_int)*natt);
          EXIT_IF(attide == NULL,NULL,NULL);
          attval = (med_int*) malloc(sizeof(med_int)*natt);
          EXIT_IF(attval == NULL,NULL,NULL);
          attdes = (char *) malloc(MED_TAILLE_DESC*natt+1);
          EXIT_IF(attdes == NULL,NULL,NULL);
        } else {
          attide = NULL;
          attval = NULL;
          attdes = NULL;
        }
        if (ngro > 0) {
          gro = (char*) malloc(MED_TAILLE_LNOM*ngro+1);
          EXIT_IF(gro == NULL,NULL,NULL);
        } else {
          gro = NULL;
        }

        ret = MEDfamInfo(fid,nommaa,i+1,nomfam,&numfam,attide,attval,
                             attdes,&natt,gro,&ngro);
        EXIT_IF(ret < 0,"lors de la lecture des informations d'une famille",
                NULL);

        /* affichage des resultats */
        fprintf(stdout,"  - Famille de nom %s et de numero %d : \n",nomfam,numfam);
        fprintf(stdout,"  - Attributs : \n");
        for (j=0;j<natt;j++) {
          strncpy(str1,attdes+j*MED_TAILLE_DESC,MED_TAILLE_DESC);
          str1[MED_TAILLE_DESC] = '\0';
          fprintf(stdout,"   identificateur = %d - valeur = %d - description = %s\n",*(attide+j),
                  *(attval+j),str1);
        }

        free(attide);
        free(attval);
        free(attdes);

        fprintf(stdout,"  - Groupes :\n");
        for (j=0;j<ngro;j++) {
          strncpy(str2,gro+j*MED_TAILLE_LNOM,MED_TAILLE_LNOM);
          str2[MED_TAILLE_LNOM] = '\0';
          fprintf(stdout,"   groupe %d  = %s\n",j+1,str2);
        }

        free(gro);
      }

      /****************************************************************************
       *                       LECTURE DES EQUIVALENCES                            *
       ****************************************************************************/
      fprintf(stdout,"\n(******************************)\n");
      fprintf(stdout,"(* EQUIVALENCES DU MAILLAGE : *)\n");
      fprintf(stdout,"(******************************)\n");

      if (nequ == 0)
        fprintf(stdout,"- Aucune équivalence \n");

      /* lecture de toutes les equivalences associes a nommaa */
      for (i = 0;i<nequ;i++) {
        fprintf(stdout,"- Equivalence numero : %d ",i+1);

        /* lecture des infos sur l'equivalence */
        ret = MEDequivInfo(fid,nommaa,i+1,equ,des);
        EXIT_IF(ret < 0,"lors de la lecture des informations sur une equivalence",
                NULL);
        fprintf(stdout,"\n  - Nom de l'equivalence: %s \n",equ);
        fprintf(stdout,"\n  - Description de l'equivalence : %s \n",des);

        /* lecture des correspondances sur les differents types d'entites */

        /* les noeuds */
        ncor = MEDnCorres(fid,nommaa,equ,MED_NOEUD,0);
        EXIT_IF(ncor < 0,"lors de la lecture du nombre de correspondances d'une equivalence",
                NULL);
        fprintf(stdout,"\n  - Il y a %d correspondances sur les noeuds \n",ncor);

        if (ncor > 0) {

          /* allocation memoire */
          cor = (med_int*) malloc(sizeof(med_int)*ncor*2);
          EXIT_IF(cor == NULL,NULL,NULL);

          ret = MEDequivLire(fid,nommaa,equ,cor,ncor,MED_NOEUD,0);
          EXIT_IF(ret < 0,"lors de la lecture du tableau des correspondances",
                  NULL);
          for (j=0;j<ncor;j++)
            fprintf(stdout,"\n  - Correspondance %d : %d et %d \n",j+1,*(cor+2*j),
                          *(cor+2*j+1));
          free(cor);
        }

        /* sur les mailles : on ne prend pas en compte les mailles 3D */
        for (j=0;j<NBR_MAILLE_EQU;j++) {

          ncor = MEDnCorres(fid,nommaa,equ,MED_MAILLE,typmai[j]);
          EXIT_IF(ncor < 0,"lors de la lecture du nombre de correspondances dans une equivalence",
                  NULL);
          fprintf(stdout,"\n  - Il y a %d correspondances sur les mailles %s \n",ncor,
                  nommai[j]);

          if (ncor > 0) {

            /* allocation memoire */
            cor = (med_int*) malloc(sizeof(med_int)*ncor*2);
            EXIT_IF(cor == NULL,NULL,NULL);

            ret = MEDequivLire(fid,nommaa,equ,cor,ncor,MED_MAILLE,
                               typmai[j]);
            EXIT_IF(ret < 0,"lors de la lecture du tableau des equivalences",
                    NULL);

            for (k=0;k<ncor;k++)
              fprintf(stdout,"\n  - Correspondance %d : %d et %d \n",k+1,*(cor+2*k),
                      *(cor+2*k+1));

            free(cor);
          }
        }

        /* sur les faces */
        for (j=0;j<MED_NBR_GEOMETRIE_FACE;j++) {

          ncor = MEDnCorres(fid,nommaa,equ,MED_FACE,typfac[j]);
          EXIT_IF(ncor < 0,"lors de la lecture du nombre de correspondances dans une equivalence",
                  NULL);
          fprintf(stdout,"\n  - Il y a %d correspondances sur les faces %s\n",ncor,
                  nomfac[j]);

          if (ncor > 0) {

            /* allocation memoire */
            cor = (med_int*) malloc(sizeof(med_int)*ncor*2);
            EXIT_IF(cor == NULL,NULL,NULL);

            ret = MEDequivLire(fid,nommaa,equ,cor,ncor,MED_FACE,
                               typfac[j]);
            EXIT_IF(ret < 0,"lors de la lecture du tableau des equivalences",
                    NULL);

            for (k=0;k<ncor;k++)
              fprintf(stdout,"\n  - Correspondance %d : %d et %d \n",k+1,*(cor+2*k),
                              *(cor+2*k+1));

            free(cor);
          }
        }

        /*  sur les aretes */
        for (j=0;j<MED_NBR_GEOMETRIE_ARETE;j++) {

          ncor = MEDnCorres(fid,nommaa,equ,MED_ARETE,typare[j]);
          EXIT_IF(ncor < 0,"lors de la lecture du nombre de correspondances",
                  NULL);
          fprintf(stdout,"\n  - Il y a %d correspondances sur les aretes %s \n",
                  ncor,nomare[j]);

          if (ncor > 0) {

            /* allocation memoire */
            cor = (med_int*) malloc(sizeof(med_int)*ncor*2);
            EXIT_IF(cor == NULL,NULL,NULL);

            ret = MEDequivLire(fid,nommaa,equ,cor,ncor,MED_ARETE,
                               typare[j]);
            EXIT_IF(ret < 0,"lors de la lecture du tableau des equivalences",
                    NULL);

            for (k=0;k<ncor;k++)
              fprintf(stdout,"\n  Correspondance %d : %d et %d \n",k+1,*(cor+2*k),
                            *(cor+2*k+1));

            free(cor);
          }
        }
      }

      /****************************************************************************
       *                       LECTURE DES JOINTS                                 *
       ****************************************************************************/
      fprintf(stdout,"\n(******************************)\n");
      fprintf(stdout,"(* JOINTS DU MAILLAGE       : *)\n");
      fprintf(stdout,"(******************************)\n");

      if (njnt == 0)
        fprintf(stdout,"- Aucun joint \n");

      /* lecture de touts les joints associes a nommaa */
      for (i = 0;i<njnt;i++) {
        fprintf(stdout,"- Joint numero : %d ",i+1);

        /* lecture des infos sur le joint */
        ret=MEDjointInfo(fid,nommaa,i+1,jn,des,&ndom,maa_dist);
        EXIT_IF(ret < 0,"lors de la lecture des informations sur un joint",
                NULL);
        fprintf(stdout,"\n  - Nom du joint: %s \n",jn);
        fprintf(stdout,"\n  - Description du joint      : %s ",des);
        fprintf(stdout,"\n  - Domaine en regard         : %d ",ndom);
        fprintf(stdout,"\n  - Maillage distant          : %s ",maa_dist);

        /* lecture des correspondances sur les differents types d'entites */
        /* recherche du type des entites en regard... passage par toutes les combinaisons */
        for (geo_ent_local=0;nc>0 && geo_ent_local<nb_geo_ent;geo_ent_local++) {
            for (geo_ent_distant=0;nc>0 && geo_ent_distant<nb_geo_ent;geo_ent_distant++) {
              typ_ent_local = typ_geo_ent[geo_ent_local][0];
              typ_geo_local = typ_geo_ent[geo_ent_local][1];
              typ_ent_distant = typ_geo_ent[geo_ent_distant][0];
              typ_geo_distant = typ_geo_ent[geo_ent_distant][1];

              if (nent=MEDjointnCorres(fid,nommaa,jn,typ_ent_local,typ_geo_local,typ_ent_distant,typ_geo_distant)) {
                if (nent > 0) {
                  fprintf(stdout,"\n\t\t- nb de couples d'entites en regard (local,distant)=(%s,%s) : %d \n",
                          nom_geo_ent[geo_ent_local],nom_geo_ent[geo_ent_distant],nent);
                  fprintf(stdout,"  %d \n",nent);
                  cortab = (med_int*) malloc(sizeof(med_int)*nent*2);
                  if (MEDjointLire(fid,nommaa,jn,cortab,nc*2,
                                       typ_ent_local,typ_geo_local,typ_ent_distant,typ_geo_distant) < 0) {
                    fprintf(stdout,"\n\t\t- Erreur a la lecture des correspondances sur (%d,%d,%d,%d)",
                            typ_ent_local,typ_geo_local,typ_ent_distant,typ_geo_distant,0);
                  }
                  else {
                    for (k=0;k<nent;k++)
                      fprintf(stdout,"\n\t\t- Correspondance %d : %d et %d ",k+1,*(cortab+2*k),
                             *(cortab+2*k+1));
                  }
                  free(cortab);
                }
                nc--;

              }
            }
          }

      }

      return;
    }

    /******************************************************************************
     *
     * - Nom de la fonction : lecture_maillage_structure
     * - Description : lecture et affichage d'un maillage MED__STRUCTURE.
     * - Parametres :
     *     - fid                       (IN) : ID du fichier MED.
     *     - nommaa                    (IN) : nom du maillage a lire.
     *     - mdim                      (IN) : dimension du maillage.
     *     - mode_coo                  (IN) : mode de stockage en memoire :
     *                                        MED_FULL_INTERLACE | MED_NO_INTERLACE.
     *     - lecture_en_tete_seulement (IN) : mode de lecture.
     *
     ******************************************************************************/

    void lecture_maillage_structure(med_idt fid,char *nommaa,med_int mdim,
                                    med_mode_switch mode_coo,int lecture_en_tete_seulement)
    {
      med_err ret = 0;
      med_int axe,i,j;
      med_int nind;
      char comp_ind[MED_TAILLE_PNOM+1];
      char unit_ind[MED_TAILLE_PNOM+1];
      char comp[3*MED_TAILLE_PNOM+1];
      char unit[3*MED_TAILLE_PNOM+1];
      char str[MED_TAILLE_PNOM+1];
      med_float *coo,*indices;
      med_int *structure_grille;
      med_table quoi;
      med_int nnoe;
      med_type_grille type;
      med_repere repere;
      /* familles */
      med_int nfam;
      med_int natt,ngro;
      char *attdes,*gro;
      med_int *attval,*attide;
      char nomfam[MED_TAILLE_NOM+1];
      med_int numfam, *nufano;
      char str1[MED_TAILLE_DESC+1];
      char str2[MED_TAILLE_LNOM+1];

      ret = MEDnatureGrilleLire(fid,nommaa,&type);
      EXIT_IF(ret < 0,"lors de lecture du type d'une grille ",NULL);

      switch(type) {

      case MED_GRILLE_CARTESIENNE:
        fprintf(stdout,"- Type de grille : MED_GRILLE_CARTESIENNE \n");
        nnoe = 1;
        for (axe=1;axe<=mdim;axe++) {
          switch(axe) {

          case 1:
            quoi = MED_COOR_IND1;
            break;

          case 2:
            quoi = MED_COOR_IND2;
            break;

          case 3:
            quoi = MED_COOR_IND3;
            break;
          }
          nind = MEDnEntMaa(fid,nommaa,quoi,MED_NOEUD,0,0);
          nnoe = nind * nnoe;
          EXIT_IF(nind < 0,"lors de la lecture de la taille d'un indice d'une grille",
                  NULL);
          fprintf(stdout,"- Taille de l'indice de l'axe %d des coordonnees : %d \n",axe,nind);
        }
        break;

      case MED_GRILLE_POLAIRE:
        fprintf(stdout,"- Type de grille : MED_GRILLE_POLAIRE \n");
        nnoe = 1;
        for (axe=1;axe<=mdim;axe++) {
          switch(axe) {

          case 1:
            quoi = MED_COOR_IND1;
            break;

          case 2:
            quoi = MED_COOR_IND2;
            break;

          case 3:
            quoi = MED_COOR_IND3;
            break;
          }
          nind = MEDnEntMaa(fid,nommaa,quoi,MED_NOEUD,0,0);
          nnoe = nind * nnoe;
          EXIT_IF(nind < 0,"lors de la lecture de la taille d'un indice d'une grille",
                  NULL);
          fprintf(stdout,"- Taille de l'indice de l'axe %d des coordonnees : %d \n",axe,nind);
        }
        break;

      case MED_GRILLE_STANDARD:
        fprintf(stdout,"- Type de grille : MED_GRILLE_DESTRUCTUREE \n");
        nnoe = MEDnEntMaa(fid,nommaa,MED_COOR,MED_NOEUD,0,0);
        EXIT_IF(nnoe < 0,"lors de la lecture du nombre de noeuds du maillage ",nommaa);
        fprintf(stdout,"- Nombre de noeuds : %d \n",nnoe);
        break;
      }

      /* nombre de familles */
      nfam = MEDnFam(fid,nommaa);
      EXIT_IF(nfam < 0,"lors de la lecture du nombre de familles",NULL);
      fprintf(stdout,"- Nombre de familles : %d \n",nfam);

      if (lecture_en_tete_seulement)
        return ;

      fprintf(stdout,"\n(*************************)\n");
      fprintf(stdout,"(* NOEUDS DE LA GRILLE : *)\n");
      fprintf(stdout,"(*************************)\n");

      switch(type) {

      case MED_GRILLE_CARTESIENNE :
      case MED_GRILLE_POLAIRE :
        /* on affiche les coordonnees de chacun des axes */
        for (axe = 1; axe<=mdim; axe++) {
          /* on alloue la memoire */
          indices = (med_float *) malloc(sizeof(med_float)*nind);
          EXIT_IF(indices == NULL,NULL,NULL);
          /* on lit le tableau des indices de coordonnees
             et on affiche le resultat */
          ret = MEDindicesCoordLire(fid,nommaa,mdim,indices,nind,
                                    axe,comp_ind,unit_ind);
          EXIT_IF(ret < 0,"lors de la lecture d'un tableau d'indice",
                  NULL);
          fprintf(stdout,"\n - Axe %s [%s] : [ ",comp_ind,unit_ind);
          for (j=0;j<nind;j++)
            fprintf(stdout," %f ",*(indices+j));
          printf(" ] \n");
          /* on nettoie la memoire */
          free(indices);
        }
        break;

      case MED_GRILLE_STANDARD:
        /* on alloue la memoire */
        structure_grille = (med_int *) malloc(sizeof(med_int)*mdim);
        EXIT_IF(structure_grille == NULL,NULL,NULL);
        /* on lit la structure de la grille
           et on affiche le resultat */
        ret = MEDstructureCoordLire(fid,nommaa,mdim,structure_grille);
        EXIT_IF(ret < 0,"lors de la lecture de la structure de la grille",
                NULL);
        for (j=0;j<mdim;j++)
          fprintf(stdout," %d ",*(structure_grille+j));
        fprintf(stdout," ] \n");
        /* on nettoie la memoire */
        free(structure_grille);

        /* on alloue la memoire */
        coo = (med_float *) malloc(sizeof(med_float)*nnoe*mdim);
        EXIT_IF(coo == NULL,NULL,NULL);
        /* on va lire les coordonnees des noeuds */
        ret = MEDcoordLire(fid,nommaa,mdim,coo,MED_FULL_INTERLACE,MED_ALL,NULL,0,
                                 &repere,comp,unit);
        EXIT_IF(ret < 0,"lors de la lecture des noeuds du maillage",NULL);
        /* on affiche le resultat */
        fprintf(stdout,"- Nom des coordonnees : \n");
        for (i=0;i<mdim;i++) {
          strncpy(str,comp+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
          str[MED_TAILLE_PNOM] = '\0';
          fprintf(stdout," %s ",str);
        }
        fprintf(stdout,"\n- Unites des coordonnees : \n");
        for (i=0;i<mdim;i++) {
          strncpy(str,unit+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
          str[MED_TAILLE_PNOM] = '\0';
          fprintf(stdout," %s ",str);
        }
        fprintf(stdout,"\n - Coordonnees des noeuds : [ ");
        for (j=0;j<nnoe*mdim;j++)
          fprintf(stdout," %f ",*(coo+j));
        fprintf(stdout," ] \n");
        /* on nettoie la memoire */
        free(coo);
        break;
      }

      /* lecture des numeros de familles de noeuds */

      /* on alloue la memoire */
      nufano = (med_int *) malloc(sizeof(med_int)*nnoe);
      EXIT_IF(nufano == NULL,NULL,NULL);

      /* on va lire les numeros de familles des noeuds */
      ret = MEDfamLire(fid,nommaa,nufano,nnoe,MED_NOEUD,0);
      EXIT_IF(ret < 0,"lors de la lecture des numeros de familles des noeuds",
              NULL);

      /* on affiche le resultat */
      fprintf(stdout,"\n- Numeros des familles des noeuds : \n");
      for (i=0;i<nnoe;i++)
        fprintf(stdout," %d ",*(nufano+i));
      fprintf(stdout,"\n");

      printf("\n(*************************)\n");
      printf("(* FAMILLES DU MAILLAGE : *)\n");
      printf("(*************************)\n");

      for (i=0;i<nfam;i++) {

        /* nombre de groupes */
        ngro = MEDnGroupe(fid,nommaa,i+1);
        EXIT_IF(ngro < 0,"lors de la lecture du nombre de groupe d'une famille",NULL);

        /* nombre d'attributs */
        natt = MEDnAttribut(fid,nommaa,i+1);
        EXIT_IF(natt < 0,"lors de la lecture du nombre d'attributs d'une famille",NULL);

        fprintf(stdout,"- Famille %d a %d attributs et %d groupes \n",i+1,natt,ngro);

        /* nom,numero,attributs,groupes */

        /* allocation memoire */
        attide = (med_int*) malloc(sizeof(med_int)*natt);
        EXIT_IF(attide == NULL,NULL,NULL);
        attval = (med_int*) malloc(sizeof(med_int)*natt);
        EXIT_IF(attval == NULL,NULL,NULL);
        attdes = (char *) malloc(MED_TAILLE_DESC*natt+1);
        EXIT_IF(attdes == NULL,NULL,NULL);
        gro = (char*) malloc(MED_TAILLE_LNOM*ngro+1);
        EXIT_IF(gro == NULL,NULL,NULL);

        ret = MEDfamInfo(fid,nommaa,i+1,nomfam,&numfam,attide,attval,
                         attdes,&natt,gro,&ngro);
        EXIT_IF(ret < 0,"lors de la lecture des informations d'une famille",
                NULL);

        /* affichage des resultats */
        fprintf(stdout,"  - Famille de nom %s et de numero %d : \n",nomfam,numfam);
        fprintf(stdout,"  - Attributs : \n");
        for (j=0;j<natt;j++) {
          strncpy(str1,attdes+j*MED_TAILLE_DESC,MED_TAILLE_DESC);
          str1[MED_TAILLE_DESC] = '\0';
          fprintf(stdout,"   ide = %d - val = %d - des = %s\n",*(attide+j),
                  *(attval+j),str1);
        }

        free(attide);
        free(attval);
        free(attdes);

        fprintf(stdout,"  - Groupes :\n");
        for (j=0;j<ngro;j++) {
          strncpy(str2,gro+j*MED_TAILLE_LNOM,MED_TAILLE_LNOM);
          str2[MED_TAILLE_LNOM] = '\0';
          fprintf(stdout,"   gro = %s\n",str2);
        }

        free(gro);
      }

      return ;
    }

    med_err getFieldsOn(med_idt fid, char * nomcha, med_type_champ typcha, med_int ncomp,
                        med_entite_maillage entite, med_mode_switch stockage) {

      int j,k,l,m,n,nb_geo;
      med_int nbpdtnor=0,pflsize,*pflval,ngauss=0,*vale=NULL,nval;
      med_int numdt=0,numo=0,lnsize,nbrefmaa;
      med_float *valr=NULL,dt=0.0;
      med_err ret=0;
      med_booleen local;
      char pflname [MED_TAILLE_NOM+1]="";
      char locname [MED_TAILLE_NOM+1]="";
      char * lien = NULL;
      char maa_ass [MED_TAILLE_NOM+1]="";
      char dt_unit [MED_TAILLE_PNOM+1]="";

      med_geometrie_element * type_geo;
      med_geometrie_element typ_noeud[1] = { MED_NONE };
      med_geometrie_element typmai[MED_NBR_GEOMETRIE_MAILLE+2] = {MED_POINT1, MED_SEG2, MED_SEG3, MED_TRIA3,
                                                                  MED_QUAD4, MED_TRIA6,MED_QUAD8, MED_TETRA4,
                                                                  MED_PYRA5, MED_PENTA6, MED_HEXA8, MED_TETRA10,
                                                                  MED_PYRA13, MED_PENTA15, MED_HEXA20,
                                                                  MED_POLYGONE, MED_POLYEDRE};
      med_geometrie_element typfac[MED_NBR_GEOMETRIE_FACE+1] = {MED_TRIA3,MED_TRIA6,
                                                                MED_QUAD4,MED_QUAD8,
                                                                MED_POLYGONE};
      med_geometrie_element typare[MED_NBR_GEOMETRIE_ARETE] = {MED_SEG2,MED_SEG3};

      char ** AFF;

      switch (entite) {
      case MED_NOEUD :
        type_geo = typ_noeud;
        nb_geo   = 1;
        AFF      = MED_GEOMETRIE_NOEUD_AFF;
        break;
      case  MED_MAILLE :
        type_geo = typmai;
        nb_geo   = MED_NBR_GEOMETRIE_MAILLE+2;
        AFF      =  MED_GEOMETRIE_MAILLE_AFF;
        break;
      case  MED_FACE :
        type_geo = typfac;
        nb_geo   = MED_NBR_GEOMETRIE_FACE+1;
        AFF      =  MED_GEOMETRIE_FACE_AFF;
        break;
      case  MED_ARETE :
        type_geo = typare;
        nb_geo   = MED_NBR_GEOMETRIE_ARETE;
        AFF      =  MED_GEOMETRIE_ARETE_AFF;
       break;
      }

      for (k=0;k<nb_geo;k++) {

        /* Combien de (PDT,NOR) a lire */
        nbpdtnor = MEDnPasdetemps(fid,nomcha,entite,type_geo[k]);
        if (nbpdtnor < 1 ) continue;

        for (j=0;j<nbpdtnor;j++) {

          if ( MEDpasdetempsInfo(fid,nomcha,entite,type_geo[k],
                                 j+1, &ngauss, &numdt, &numo, dt_unit,
                                 &dt, maa_ass, &local, &nbrefmaa) <0) {
            MESSAGE("Erreur a la demande d'information sur (pdt,nor) : ");
            ISCRUTE(numdt); ISCRUTE(numo);
            ret = -1; continue;
          };

          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);

          printf("\tLe maillage par defaut est : |%s|, sur un total de : %i maillages associes\n",
                 maa_ass, nbrefmaa);

          /* Le maillage reference est-il porte par un autre fichier */
          if ( !local ) {

            if ( (lnsize=MEDnValLien(fid,maa_ass) ) < 0 )  {
              MESSAGE("Erreur a la lecture de la taille du lien : ");
              SSCRUTE(maa_ass);
              ret = -1;
            } else {

              lien = malloc(lnsize*sizeof(char));
              EXIT_IF(lien == NULL,NULL,NULL);

              if ( MEDlienLire(fid, lien, maa_ass) < 0 )  {
                MESSAGE("Erreur a la lecture du lien : ");
                SSCRUTE(maa_ass);SSCRUTE(lien);
                ret = -1;
              } else {
                printf("\tLe maillage |%s| est porte par un fichier distant |%s|\n",maa_ass,lien);
              }
              free(lien);
            }
          }

          /* Combien de maillages lies aux (nomcha,ent,geo,numdt,numo)  */
          /* Notons que cette information est egalement disponible a partir de MEDpasdetempsInfo */
          if ( (nbrefmaa = MEDnChampRef(fid,nomcha,entite,type_geo[k],numdt,numo) ) < 0 ) {
            MESSAGE("Erreur a la demande du nombre de maillages references par le champ : ");
            SSCRUTE(nomcha); ISCRUTE(numdt); ISCRUTE(numo);
            ret = -1; continue;
          };

          for (l=0;l<nbrefmaa;l++) {

            if ( MEDchampRefInfo(fid,nomcha,entite,type_geo[k],
                                 l+1,numdt, numo, maa_ass, &local, &ngauss) <0 ) {
              MESSAGE("Erreur a la demande d'information sur le maillage utilise par le champ n° : ");
              ISCRUTE(l+1);
              ret = -1; continue;
            };

            /* Prend en compte le nbre de pt de gauss automatiquement */
            if ((nval = MEDnVal(fid,nomcha,entite,type_geo[k],numdt,numo,maa_ass,USER_MODE)) <= 0)   {
              MESSAGE("Erreur a la lecture du nombre de valeurs du champ : ");
              SSCRUTE(nomcha);ISCRUTE(entite);ISCRUTE(type_geo[k]);
              ISCRUTE(numdt);ISCRUTE(numo);SSCRUTE(maa_ass);ISCRUTE(USER_MODE);
              ret = -1; continue;
            };

            printf("\t- Il y a %d valeurs en mode %i. Chaque entite %s\
     de type geometrique %s associes au maillage |%s| a %i pts de gauss \n",
                   nval,USER_MODE,MED_ENTITE_MAILLAGE_AFF[(int)entite],AFF[k],maa_ass,ngauss);

            /* Le maillage reference est-il porte par un autre fichier */
            if ( !local ) {

              if ( (lnsize=MEDnValLien(fid,maa_ass) ) < 0 )  {
                MESSAGE("Erreur a la lecture de la taille du lien : ");
                SSCRUTE(maa_ass);
                ret = -1;
              } else {

                lien = malloc(lnsize*sizeof(char));
                EXIT_IF(lien == NULL,NULL,NULL);

                if ( MEDlienLire(fid, lien, maa_ass) < 0 )  {
                  MESSAGE("Erreur a la lecture du lien : ");
                  SSCRUTE(maa_ass);SSCRUTE(lien);
                  ret = -1;
                } else {
                  printf("\tLe maillage |%s| est porte par un fichier distant |%s|\n",maa_ass,lien);
                }
                free(lien);
              }
            }

            /*Lecture des valeurs du champ */
            if (typcha == MED_FLOAT64) {

              valr = (med_float*) calloc(ncomp*nval,sizeof(med_float));
              EXIT_IF(valr == NULL,NULL,NULL);
              if ( MEDchampLire(fid,maa_ass,nomcha,(unsigned char*)valr,stockage,MED_ALL,locname,
                                pflname,USER_MODE,entite,type_geo[k],numdt,numo) < 0 ) {
                MESSAGE("Erreur a la lecture du nombre de valeurs du champ : ");
                SSCRUTE(nomcha);ISCRUTE(entite);ISCRUTE(type_geo[k]);
                ISCRUTE(numdt);ISCRUTE(numo);SSCRUTE(maa_ass);
                ret = -1;
              };

            } else {

              vale = (med_int*) calloc(ncomp*nval,sizeof(med_int));
              EXIT_IF(vale == NULL,NULL,NULL);
              if ( MEDchampLire(fid,maa_ass,nomcha,(unsigned char*)vale,stockage,MED_ALL,locname,
                                pflname,USER_MODE,entite,type_geo[k],numdt,numo) < 0 ) {
                MESSAGE("Erreur a la lecture des valeurs du champ : ");
                SSCRUTE(nomcha);ISCRUTE(entite);ISCRUTE(type_geo[k]);
                ISCRUTE(numdt);ISCRUTE(numo);SSCRUTE(maa_ass);
                ret = -1;
              };

            }

          switch (stockage) {

          case MED_FULL_INTERLACE :
            printf("\t- Valeurs :\n\t");
            for (m=0;m<nval/ngauss;m++) {
              printf("|");
              for (n=0;n<ngauss*ncomp;n++)
                if (typcha == MED_FLOAT64)
                  printf(" %f ",*(valr+(m*ngauss*ncomp)+n));
                else
                  printf(" %d ",*(vale+(m*ngauss*ncomp)+n));

            }
            break;

          case MED_NO_INTERLACE :
            printf("\t- Valeurs :\n\t");
            for (m=0;m<ncomp;m++) {
              printf("|");
              for (n=0;n<nval;n++)
                if (typcha == MED_FLOAT64)
                  printf(" %f ",*(valr+(m*nval)+n));
                else
                  printf(" %d ",*(vale+(m*nval)+n));
            }
            break;
          }

          printf("|\n");
          if (typcha == MED_FLOAT64) {
            if ( valr ) {free(valr);valr = NULL;}}
          else
            if (vale) { free(vale);vale = NULL; }

          /*Lecture du profil associe */
          if (strcmp(pflname,MED_NOPFL) == 0 )
            printf("\t- Profil : MED_NOPFL\n");
          else {

              if ( (pflsize = MEDnValProfil(fid,pflname)) <0 )  {
                MESSAGE("Erreur a la lecture du nombre de valeurs du profil : ");
                SSCRUTE(pflname);
                ret = -1; continue;
              }

              printf("\t- Profil : |%s| de taille %i\n",pflname,pflsize);

              pflval = (med_int*) malloc(sizeof(med_int)*pflsize);
              EXIT_IF(pflval == NULL,NULL,NULL);
              if ( MEDprofilLire(fid,pflval,pflname) <0) {
                MESSAGE("Erreur a la lecture des valeurs du profil : ");
                SSCRUTE(pflname);
                ret = -1;
              }
              printf("\t");
              for (m=0;m<pflsize;m++) printf(" %i ",*(pflval+m));
              printf("\n");
              free(pflval);

            }

          }
        }
      } /* fin for sur les mailles*/

      return ret;
    }

    /******************************************************************************
     *
     * - Nom de la fonction : lecture_resultats
     * - Description : lecture et affichage des champs de resultats
     *                 associe a un  maillage MED.
     * - Parametres :
     *     - fid                       (IN) : ID du fichier MED.
     *     - mdim                      (IN) : dimension du maillage.
     *     - mode_coo                  (IN) : mode de stockage en memoire :
     *                                        MED_FULL_INTERLACE | MED_NO_INTERLACE.
     *     - lecture_en_tete_seulement (IN) : mode de lecture.
     *
     ******************************************************************************/

    void lecture_resultats(med_idt fid,
                           med_mode_switch mode_coo,int lecture_en_tete_seulement)
    {
      med_err ret,lret;
      char pflname[MED_TAILLE_NOM+1]="",nomlien[MED_TAILLE_NOM+1]="";
      char * lien = NULL;
      char *comp, *unit;
      char nomcha  [MED_TAILLE_NOM+1]="";
      char locname[MED_TAILLE_NOM+1]="";
      med_int mdim,ncomp,ncha,npro,nln,pflsize,*pflval,nval,nloc,ngauss;
      med_type_champ typcha;
      med_maillage type;
      int t1,t2,t3;
      med_geometrie_element type_geo;
      med_float *refcoo, *gscoo, *wg;
      int i,j;

      if (! lecture_en_tete_seulement) {
        fprintf(stdout,"\n(************************)\n");
        fprintf(stdout,"(* CHAMPS DU MAILLAGE : *)\n");
        fprintf(stdout,"(************************)\n");
      }

      /* combien de champs dans le fichier */
      ncha = MEDnChamp(fid,0);
      EXIT_IF(ncha < 0,"lors de la lecture du nombre de champs",NULL);
      fprintf(stdout,"- Nombre de champs : %d \n",ncha);

      if (lecture_en_tete_seulement)
        return;

      /****************************************************************************
      *                       LECTURE DES CHAMPS                                  *
      ****************************************************************************/
      ret = 0;

      /* lecture de tous les champs  */
      for (i =0;i<ncha;i++) {
        lret = 0;
        printf("\nChamp numero : |%d| \n",i+1);

        /* Lecture du nombre de composantes */
        if ((ncomp = MEDnChamp(fid,i+1)) < 0) {
          MESSAGE("Erreur à la lecture du nombre de composantes : "); ISCRUTE(ncomp);
          ret = -1; continue;
        }

        /* Lecture du type du champ, des noms des composantes et du nom de l'unité*/
        comp = (char*) malloc(ncomp*MED_TAILLE_PNOM+1);
        EXIT_IF(comp == NULL,NULL,NULL);
        unit = (char*) malloc(ncomp*MED_TAILLE_PNOM+1);
        EXIT_IF(unit == NULL,NULL,NULL);

        if ( MEDchampInfo(fid,i+1,nomcha,&typcha,comp,unit,ncomp) < 0 ) {
          MESSAGE("Erreur à la demande d'information sur les champs : ");
          ret = -1; continue;
        }

        printf("Nom du champ : |%s| de type |%d|\n",nomcha,typcha);
        printf("Nom des composantes : |%s|\n",comp);
        printf("Unites des composantes : |%s| \n",unit);

        free(comp);
        free(unit);

        lret = getFieldsOn(fid, nomcha, typcha, ncomp, MED_NOEUD,mode_coo);

        if (lret == 0) lret = getFieldsOn(fid, nomcha, typcha, ncomp, MED_MAILLE,mode_coo);
        else { MESSAGE("Erreur à la lecture des champs aux noeuds "); ret = -1; continue;}

        if (lret == 0) lret = getFieldsOn(fid, nomcha, typcha, ncomp, MED_FACE,mode_coo);
        else { MESSAGE("Erreur à la lecture des champs aux mailles "); ret = -1; continue;}

        if (lret == 0) lret = getFieldsOn(fid, nomcha, typcha, ncomp, MED_ARETE,mode_coo);
        else {MESSAGE("Erreur à la lecture des champs aux faces "); ret = -1; continue;}

        if  (lret != 0) {MESSAGE("Erreur à la lecture des champs aux aretes "); ret = -1;};
      }

      /* Interrogation des profils */
      npro = MEDnProfil(fid);

      printf("\nNombre de profils stockes : %i\n\n",npro);
      for (i=1 ; i <= npro ; i++ ) {
        if ( MEDprofilInfo(fid, i, pflname, &nval) < 0)  {
          MESSAGE("Erreur a la demande d'information sur le profil n° : "); ISCRUTE(i);
          ret = -1;continue;
        }
        printf("\t- Profil n°%i de nom |%s| et de taille %i\n",i,pflname,nval);
        pflval = (med_int*) malloc(sizeof(med_int)*nval);
        if ( MEDprofilLire(fid, pflval, pflname) < 0) {
          MESSAGE("Erreur a la lecture des valeurs du profil : ");
          SSCRUTE(pflname);
          ret = -1;
        } else {
          printf("\t");
          for (j=0;j<nval;j++) printf(" %i ",*(pflval+j));
          printf("\n\n");
        }
        free(pflval);
      }

      /* Interrogation des liens */
      nln = MEDnLien(fid);

      printf("\nNombre de liens stockes : %i\n\n",nln);
      for (i=1 ; i <= nln ; i++ ) {
        if ( MEDlienInfo(fid, i, nomlien, &nval) < 0)  {
          MESSAGE("Erreur a la demande d'information sur le lien n° : "); ISCRUTE(i);
          ret = -1;continue;
        }
        printf("\t- Lien n°%i de nom |%s| et de taille %i\n",i,nomlien,nval);

        lien = malloc(nval*sizeof(char));
        EXIT_IF(lien == NULL,NULL,NULL);

        if ( MEDlienLire(fid, lien, nomlien) < 0 )  {
          MESSAGE("Erreur a la lecture du lien : ");
          SSCRUTE(nomlien);SSCRUTE(lien);
          ret = -1;
        } else
          printf("\t\t|%s|\n\n",lien);
        free(lien);
      }

      /* Interrogation des localisations des points de GAUSS */
      nloc = MEDnGauss(fid);

      printf("\nNombre de localisations stockees : %i\n\n",nloc);
      for (i=1 ; i <= nloc ; i++ ) {
        if ( MEDgaussInfo(fid, i, locname, &type_geo, &ngauss) < 0)  {
          MESSAGE("Erreur a la demande d'information sur la localisation n° : "); ISCRUTE(i);
          ret = -1;continue;
        }
        printf("\t- Loc. n°%i de nom |%s| et nbr. de pts de GAUSS %i\n",i,locname,ngauss);
        t1 = (type_geo%100)*(type_geo/100);
        t2 = ngauss*(type_geo/100);
        t3 = ngauss;
        refcoo = (med_float *) malloc(sizeof(med_float)*t1 );
        gscoo  = (med_float *) malloc(sizeof(med_float)*t2 );
        wg     = (med_float *) malloc(sizeof(med_float)*t3 );

        if ( MEDgaussLire(fid, refcoo, gscoo, wg, mode_coo, locname ) < 0) {
          MESSAGE("Erreur a la lecture des valeurs de la localisation : ");
          SSCRUTE(locname);
          ret = -1;
        } else {
          printf("\t  Coordonnees de l'element de reference de type %i :\n\t\t",type_geo);
          for (j=0;j<t1;j++) printf(" %f ",*(refcoo+j));
          printf("\n");
          printf("\t  Localisation des points de GAUSS : \n\t\t");
          for (j=0;j<t2;j++) printf(" %f ",*(gscoo+j));
          printf("\n");
          printf("\t  Poids associes aux points de GAUSS :\n\t\t");
          for (j=0;j<t3;j++) printf(" %f ",*(wg+j));
          printf("\n\n");
        }
        free(refcoo);
        free(gscoo);
        free(wg);
      }

      return;
    }

    /******************************************************************************
     *
     * - Nom de la fonction : lecture_parametres_scalaires
     * - Description : lecture des parametres scalaires definis
     *                 hors champs et maillages.
     * - Parametres :
     *     - fid                    (IN) : ID du fichier MED.
     *     - lecture_en_tete_seule  (IN) : mode de lecture.
     *
     ******************************************************************************/

    void lecture_parametres_scalaires(med_idt fid,int lecture_en_tete_seulement)
    {
      med_err ret = 0;
      char nom_scalaire[MED_TAILLE_NOM+1];
      char description[MED_TAILLE_DESC+1];
      med_int vali;
      med_float valr;
      med_int i,n,npdt,j;
      med_type_champ type;
      med_int numdt,numo;
      med_float dt;
      char dt_unit[MED_TAILLE_PNOM+1];

     fprintf(stdout,"\n(*******************************)\n");
     fprintf(stdout,"(* SCALAIRES HORS MODELE MED : *)\n");
     fprintf(stdout,"(*******************************)\n");

      /* Combien de variables scalaire ? */
      n = MEDnScalaire(fid);
      EXIT_IF(n < 0,"lors de la lecture du nombre de scalaires",NULL);
      fprintf(stdout,"- Nombre de variables scalaires : %d\n",n);

      if (lecture_en_tete_seulement)
        return ;

      for (i=1;i<=n;i++) {

        /* Lecture des infos (type,description) */
        ret = MEDscalaireInfo(fid,i,nom_scalaire,&type,description);
        EXIT_IF(ret < 0,"lors de la lecture des parametres d'un scalaire",NULL);
        printf("- Scalaire n°%d de nom %s \n",i,nom_scalaire);
        if (type == MED_FLOAT64)
          printf("  Type flottant. \n");
        else
          printf("  Type entier. \n");
        printf("  Description associee : [%s] \n",description);

        /* Pour chaque scalaire on regarde les valeurs associees
           eventuellement a des pas de temps et des numeros d'ordre */
        npdt = MEDnScalairePasdetemps(fid,nom_scalaire);
        EXIT_IF(npdt < 0,"lors de la lecture du nombre de pas de temps d'un scalaire",NULL);
        printf("   Nombre de valeurs stockees : %d \n",npdt);

        for (j=1;j<=npdt;j++) {
          ret = MEDscalairePasdetempsInfo(fid,nom_scalaire,j,
                                          &numdt,dt_unit,&dt,&numo);
          EXIT_IF(ret < 0,"lors de la lecture des parametres d'un pas de temps d'un scalaire",NULL);

          if (numdt == MED_NOPDT)
            printf("   - Aucun de pas de temps \n");
          else
            printf("   - Pas de de temps de numero %d de valeur %f [%s] \n",numdt,dt,dt_unit);
          if (numo == MED_NONOR)
            printf("   - Aucun numero d'ordre \n");
          else
            printf("   - Numero d'ordre : %d \n",numo);

          if (type == MED_FLOAT64)
            ret = MEDscalaireFlottantLire(fid,nom_scalaire,&valr,numdt,numo);
          else
            ret = MEDscalaireEntierLire(fid,nom_scalaire,&vali,numdt,numo);
          EXIT_IF(ret < 0,"lors de la lecture de la valeur d'un scalaire",NULL);

        }
      }

      return ;
    }

    /******************************************************************************
     *
     * - Nom de la fonction : main
     * - Description : outil de DUMP d'un fichier MED.
     * - Parametres :
     *     - argc  (IN) : nombre d'arguments sur la ligne de commande.
     *     - argv  (IN) : liste des arguments.
     *
     ******************************************************************************/

    int main (int argc, char **argv)
    {
      med_err ret = 0;
      int reponse;
      med_idt fid;
      int i;
      int numero;
      med_mode_switch mode_coo;
      med_connectivite typ_con;
      int lecture_en_tete_seulement = 0;
      char nom_universel[MED_TAILLE_LNOM+1];
      med_int long_fichier_en_tete;
      char *fichier_en_tete;
      char version_hdf[10];
      char version_med[10];
      med_int mdim,nmaa;
      /* nom du maillage */
      char nommaa[MED_TAILLE_NOM+1];
      char maillage_description[MED_TAILLE_DESC+1];
      med_maillage type_maillage;
      med_int edim;
      med_int majeur,mineur,release;
      med_int majeur_lu,mineur_lu,release_lu;
      med_int nprofils;

      /****************************************************************************
      *                  TEST DU NOMBRE D'ARGUMENTS                               *
      *                  argument 1 = nom du fichier MED                          *
      ****************************************************************************/
      EXIT_IF(argc != 2 && argc != 5,"nombre de parametres incorrects\n",NULL);

      /****************************************************************************
      *                      OUVERTURE DU FICHIER EN LECTURE                      *
      ****************************************************************************/

      /* on regarde s'il s'agit d'un fichier au format HDF 5 */
      ret = MEDformatConforme(argv[1]);
      EXIT_IF(ret < 0,"Le fichier n'est pas au format HDF V5 !!!",NULL);

      /* Quelle version de MED est utilise par mdump ? */
      MEDversionDonner(&majeur,&mineur,&release);
      fprintf(stdout,"- Lecture du fichier à l'aide de la bibliothèque MED-fichier V%d.%d.%d \n",majeur,mineur,release);

      fid = MEDouvrir(argv[1],MED_LECTURE);
      EXIT_IF( fid < 0,"ouverture du du fichier ",argv[1]);

      /****************************************************************************
       *                     QUESTIONS PRELIMINAIRES                               *
       *    1. Mode d'affichage des coordonnees (entrelace ou non) ?               *
       *    2. Connectivite des elements (nodale ou descendante)                   *
       ****************************************************************************/
      fprintf(stdout,"\n >>>>>> DUMP DU FICHIER %s >>>>>>\n",argv[1]);

      /* en-tete du fichier (presence optionnelle) */
      long_fichier_en_tete = MEDlFichDes(fid);
      if (long_fichier_en_tete > 0) {
        fichier_en_tete = (char *) malloc(sizeof(char)*(long_fichier_en_tete+1));
        EXIT_IF(fichier_en_tete == NULL,NULL,NULL);

        /* on va lire dans le fichier */
        ret = MEDfichEntete(fid,MED_FICH_DES,fichier_en_tete);
        if (ret < 0)
          free(fichier_en_tete);
        EXIT_IF(ret < 0,"lecture de l'en-tete du fichier",argv[1]);

        /* on affiche */
        fprintf(stdout,"- En-tete du fichier : %s \n",fichier_en_tete);
        free(fichier_en_tete);
      }

      if (argc == 2) {
        fprintf(stdout,"(*****************)\n");
        fprintf(stdout,"(* PARAMETRAGE : *)\n");
        fprintf(stdout,"(*****************)\n");
        fprintf(stdout,"- Mode d'affichage des coordonnées des noeuds ? \n");
        fprintf(stdout,"  1. Mode entrelacé : taper 1 \n");
        fprintf(stdout,"  2. Mode non entrelacé : taper 2 \n");
        reponse = 0;
        do {
          fprintf(stdout,"  Reponse : ");
          scanf("%d",&reponse);
        } while (reponse != 1 && reponse != 2);
        if (reponse == 1)
          mode_coo = MED_FULL_INTERLACE;
        else
          mode_coo = MED_NO_INTERLACE;

        fprintf(stdout,"- Connectivité des éléments ? \n");
        fprintf(stdout,"  1. Nodale : taper 1 \n");
        fprintf(stdout,"  2. Descendante : taper 2 \n");
        reponse = 0;
        do {
          fprintf(stdout,"  Reponse : ");
          scanf("%d",&reponse);
        } while (reponse != 1 && reponse != 2);
        if (reponse == 1)
          typ_con = MED_NOD;
        else
          typ_con = MED_DESC;
      }
      else {
        if (! strcmp(argv[3],"NODALE"))
          typ_con = MED_NOD;
        if (! strcmp(argv[3],"DESCENDANTE"))
          typ_con = MED_DESC;

        if (!strcmp(argv[4],"NO_INTERLACE"))
          mode_coo = MED_NO_INTERLACE;
        if (!strcmp(argv[4],"FULL_INTERLACE"))
          mode_coo = MED_FULL_INTERLACE;
        if (! strcmp(argv[4],"LECTURE_EN_TETE_SEULEMENT"))
          lecture_en_tete_seulement = 1;

      }

      /****************************************************************************
      *                      QUEL MAILLAGE LIRE                                   *
      ****************************************************************************/
      nmaa = MEDnMaa(fid);
      EXIT_IF(nmaa < 0,"lors de la lecture du nombre de maillages",NULL);

      /* Quel maillage lire ? */
      if (argc == 2) {
        fprintf(stdout,"- Il y a %d maillages dans ce fichier \n",nmaa);
        fprintf(stdout,"  Lequel voulez-vous lire (1|2|3|...|n) ?\n");
        do {
          fprintf(stdout,"  Reponse : ");
          scanf("%d",&numero);
        } while (numero > nmaa || numero <= 0);
      }
      else {
        numero = atoi(argv[2]);
        EXIT_IF(numero > nmaa || numero <= 0,"ce numero de maillage n'existe pas",NULL);
      }

      /****************************************************************************
       *                       PARAMETRES SCALAIRES HORS MODELE MED               *
       ****************************************************************************/

      /* on va lire l'ensemble des parametres scalaire */
      lecture_parametres_scalaires(fid,lecture_en_tete_seulement);

      /****************************************************************************
       *                       INFOS GENERALES SUR LE MAILLAGE                    *
       ****************************************************************************/
      fprintf(stdout,"\n(********************************************)\n");
      fprintf(stdout,"(* INFORMATIONS GENERALES SUR LE MAILLAGE : *)\n");
      fprintf(stdout,"(********************************************)\n");

      /* lecture du nom et de la dimension du maillage */
      ret = MEDmaaInfo(fid,numero,nommaa,&mdim,&type_maillage,maillage_description);
      EXIT_IF(ret < 0,"Lecture des informations sur le maillage",NULL);
      edim = MEDdimEspaceLire(fid,nommaa);
      fprintf(stdout,"- Nom du maillage : <<%s>>\n",nommaa);
      fprintf(stdout,"- Dimension du maillage : %d\n",mdim);
      if (edim > mdim)
        fprintf(stdout,"- La dimension de l'espace est %d \n",edim);
      if (type_maillage == MED_NON_STRUCTURE)
        fprintf(stdout,"- Type du maillage : MED_NON_STRUCTURE \n");
      else
        fprintf(stdout,"- Type du maillage : MED_STRUCTURE \n");
      fprintf(stdout,"- Description associee au maillage : %s\n",maillage_description);

      /* lecture du nom universel (presence optionnelle) */
     ret = MEDunvLire(fid,nommaa,nom_universel);
     if (ret == 0)
       fprintf(stdout,"- Nom universel du maillage : %s \n",nom_universel);
     else
       fprintf(stdout,"- Pas de nom universel \n");

     /****************************************************************************
      *                      LECTURE DU MAILLAGE ET DES RESULTATS ASSOCIES        *
      ****************************************************************************/

     /* en fonction du type du maillage */
     if (type_maillage == MED_NON_STRUCTURE)
       lecture_maillage_non_structure(fid,nommaa,mdim,mode_coo,typ_con,
                                      lecture_en_tete_seulement);
     else
       lecture_maillage_structure(fid,nommaa,mdim,mode_coo,
                                  lecture_en_tete_seulement);

     /* on lit ensuite les resultats */
     lecture_resultats(fid,mode_coo,lecture_en_tete_seulement);

     /****************************************************************************
     *                      FERMETURE DU FICHIER                                 *
     ****************************************************************************/
     ret = MEDfermer(fid);
     EXIT_IF(ret < 0,"lors de la fermeture du fichier",argv[1]);

     fprintf(stdout,"\n >>>>>> FIN DU DUMP DU FICHIER %s >>>>>>\n",argv[1]);

     return EXIT_SUCCESS;
    }