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