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