/****************************************************************************
* 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;
}