Back to index

salome-med  6.5.0
mdump_V2_1.cxx
Go to the documentation of this file.
00001 /******************************************************************************
00002  * - Nom du fichier : mdump.c
00003  *
00004  * - Description : utilitaire de dump pour fichier MED V2.1
00005  *
00006  *****************************************************************************/
00007 #define NBR_MAILLE_EQU 7
00008 
00009 #include <stdio.h>
00010 #include <string.h>
00011 #include <stdlib.h>
00012 
00013 #include "med.hxx"
00014 using namespace med_2_1;
00015 
00016 /*******************************************************************
00017  *  DUMP D'UN FICHIER MED STRUCTURE EN GRILLE :                    *
00018  *  NOEUDS, ELEMENTS, FAMILLES, EQUIVALENCES, CHAMPS DE RESULTATS  *
00019  *******************************************************************/
00020 
00021 int grid_cartesian_or_polar(med_idt fid, int numero, med_mode_switch mode_coo) {
00022     med_int mdim, nnoe, nfam, i, j;
00023     char nommaa[MED_TAILLE_NOM+1];
00024     char nom_universel[MED_TAILLE_LNOM+1];
00025     med_float *coo;
00026     med_int *fam;
00027     char nomcoo[3*MED_TAILLE_PNOM+1];
00028     char unicoo[3*MED_TAILLE_PNOM+1];
00029     med_repere rep;
00030     char str[MED_TAILLE_PNOM+1];
00031 
00032     fprintf(stdout,"\n(****************************)\n");
00033     fprintf(stdout,"(* INFORMATIONS GENERALES : *)\n");
00034     fprintf(stdout,"(****************************)\n");
00035 
00036     /* lecture du nom et de la dimension de la grille */
00037     if (MEDmaaInfo(fid, numero, nommaa, &mdim) < 0) {
00038         fprintf(stderr, ">> ERREUR : lecture du nom de la grille\n");
00039         return(EXIT_FAILURE);
00040     };
00041     fprintf(stdout, "- Nom de la grille : <<%s>>\n", nommaa);
00042     fprintf(stdout, "- Dimension de la grille : %d\n", mdim);
00043 
00044     /* lecture du nom universel (presence optionnelle) */
00045     if (MEDunvLire(fid, nommaa, nom_universel) > 0) {
00046         fprintf(stdout, "- Nom universel de la grille : %s \n", nom_universel);
00047     } else {
00048         fprintf(stdout, "- Pas de nom universel \n");
00049     };
00050 
00051     /* nombre de familles */
00052     nfam = MEDnFam(fid, nommaa, 0, (med_dim_famille)0);
00053     if (nfam < 0) {
00054         fprintf(stderr, ">> ERREUR : lecture du nombre de familles\n");
00055         return(EXIT_FAILURE);
00056     };
00057     fprintf(stdout, "- Nombre de familles : %d \n", nfam);
00058 
00059     fprintf(stdout, "\n- Lecture des indices : \n");
00060     for (i=0; i<mdim; i++) {
00061         fprintf(stdout, "-- Lecture de l'indice : %d\n", i);
00062         nnoe = MEDnGrid(fid, nommaa, (med_grid)i);
00063         fprintf(stdout, "-- nombre d'indice : %d\n", nnoe);
00064         coo  = (med_float*)malloc(sizeof(med_float)*nnoe);
00065 
00066         if (MEDgridLire(fid, nommaa, mdim, coo, i, mode_coo, &rep, nomcoo, unicoo) < 0) {
00067             fprintf(stderr, ">> ERREUR : lecture des indices \n");
00068             return(EXIT_FAILURE);
00069         };
00070 
00071         fprintf(stdout, "- Type de repere des coordonnees : %d \n", rep);
00072 
00073         fprintf(stdout, "- Nom des coordonnees : \n");
00074         for (j=0; j<mdim; j++) {
00075             strncpy(str, nomcoo+j*MED_TAILLE_PNOM, MED_TAILLE_PNOM);
00076             str[MED_TAILLE_PNOM] = '\0';
00077             fprintf(stdout, " %s ", str);
00078         };
00079 
00080         fprintf(stdout, "\n- Unites des coordonnees : \n");
00081         for (j=0; j<mdim; j++) {
00082             strncpy(str, unicoo+j*MED_TAILLE_PNOM, MED_TAILLE_PNOM);
00083             str[MED_TAILLE_PNOM] = '\0';
00084             fprintf(stdout, " %s ", str);
00085         };
00086 
00087         fprintf(stdout, "\n-- Coordonnees des indices : \n");
00088         for (j=0; j<nnoe; j++) {
00089             fprintf(stdout, "   %f ", *(coo+j));
00090         };
00091 
00092         fprintf(stdout, "\n\n");
00093         free(coo);
00094     };
00095 
00096     nfam = MEDnGrid(fid, nommaa, (med_grid)-2);
00097     fprintf(stdout, "- Nombre de noeud pour les familles : %d\n", nfam);
00098     if (nfam > 0) {
00099         fam = (med_int*)malloc(sizeof(med_int)*nfam);
00100         if (MEDfamGridLire(fid, nommaa, fam, nfam,MED_NOEUD) < 0) {
00101             fprintf(stderr, ">> ERREUR : lecture des familles\n");
00102             return(EXIT_FAILURE);
00103         };
00104 
00105         fprintf(stdout, "\n- Numeros des familles des noeuds :\n");
00106         for (i=0; i<nfam; i++) {
00107             fprintf(stdout, " %d ", *(fam+i));
00108         };
00109         fprintf(stdout, "\n");
00110         free(fam);
00111     };
00112 
00113     return(0);
00114 }
00115 
00116 int grid_body_fitted(med_idt fid, int numero, med_mode_switch mode_coo) {
00117     med_int mdim, nnoe, nfam, i;
00118     char nommaa[MED_TAILLE_NOM+1];
00119     char nom_universel[MED_TAILLE_LNOM+1];
00120     char str[MED_TAILLE_PNOM+1];
00121     char nomcoo[3*MED_TAILLE_PNOM+1];
00122     char unicoo[3*MED_TAILLE_PNOM+1];
00123     med_float *coo;
00124     med_int *fam;
00125     med_repere rep;
00126 
00127     fprintf(stdout,"\n(****************************)\n");
00128     fprintf(stdout,"(* INFORMATIONS GENERALES : *)\n");
00129     fprintf(stdout,"(****************************)\n");
00130 
00131     /* lecture du nom et de la dimension du maillage */
00132     if (MEDmaaInfo(fid, numero, nommaa, &mdim) < 0) {
00133         fprintf(stderr, ">> ERREUR : lecture du nom du maillage body fitted\n");
00134         return(EXIT_FAILURE);
00135     };
00136     fprintf(stdout, "- Nom du maillage body fitted : <<%s>>\n", nommaa);
00137     fprintf(stdout, "- Dimension du maillage body fitted : %d\n", mdim);
00138 
00139     /* lecture du nom universel (presence optionnelle) */
00140     if (MEDunvLire(fid, nommaa, nom_universel) > 0) {
00141         fprintf(stdout, "- Nom universel du maillage body fitted : %s \n", nom_universel);
00142     } else {
00143         fprintf(stdout, "- Pas de nom universel \n");
00144     };
00145 
00146     /* Combien de noeuds ? */
00147     /*    nnoe = MEDnGrid(fid, nommaa, -1);*/
00148     nnoe = MEDnGrid(fid, nommaa, MED_GRID_NOEUD);
00149     if (nnoe < 0) {
00150         fprintf(stderr, ">> ERREUR : lecture du nombre de noeuds (via MEDnGrid) \n");
00151         return(EXIT_FAILURE);
00152     };
00153     fprintf(stdout, "- Nombre de noeuds : %d \n", nnoe);
00154 
00155     /* Combien de noeuds dans la dimension 1 ? */
00156     i = MEDnGrid(fid, nommaa, (med_grid)0);
00157     if (i < 0) {
00158         fprintf(stderr, ">> ERREUR : lecture du nombre de noeuds (via MEDnGrid) dans la dimension 1 \n");
00159         return(EXIT_FAILURE);
00160     };
00161     fprintf(stdout, "- Nombre de noeuds dans la dimension 1 : %d \n", i);
00162 
00163     /* Combien de noeuds dans la dimension 2 ? */
00164     i = MEDnGrid(fid, nommaa, (med_grid)1);
00165     if (i < 0) {
00166         fprintf(stderr, ">> ERREUR : lecture du nombre de noeuds (via MEDnGrid) dans la dimension 2 \n");
00167         return(EXIT_FAILURE);
00168     };
00169     fprintf(stdout, "- Nombre de noeuds dans la dimension 2 : %d \n", i);
00170 
00171     /* nombre de familles */
00172     nfam = MEDnFam(fid, nommaa, 0,(med_dim_famille)0);
00173     if (nfam < 0) {
00174         fprintf(stderr, ">> ERREUR : lecture du nombre de familles \n");
00175         return(EXIT_FAILURE);
00176     };
00177     fprintf(stdout, "- Nombre de familles : %d \n", nfam);
00178 
00179     coo = (med_float*)malloc(sizeof(med_float)*nnoe*mdim);
00180     fam = (med_int*)malloc(sizeof(med_int)*nnoe);
00181 
00182     if (MEDbodyFittedLire(fid, nommaa, mdim, coo, mode_coo, &rep, nomcoo, unicoo, fam, nnoe) < 0) {
00183         fprintf(stderr, ">> ERREUR : lecture des noeuds \n");
00184         return(EXIT_FAILURE);
00185     };
00186 
00187     fprintf(stdout, "- Type de repere des coordonnees : %d \n", rep);
00188 
00189     fprintf(stdout, "- Nom des coordonnees : \n");
00190     for (i=0; i<mdim; i++) {
00191         strncpy(str, nomcoo+i*MED_TAILLE_PNOM, MED_TAILLE_PNOM);
00192         str[MED_TAILLE_PNOM] = '\0';
00193         fprintf(stdout, " %s ", str);
00194     };
00195 
00196     fprintf(stdout, "\n- Unites des coordonnees : \n");
00197     for (i=0; i<mdim; i++) {
00198         strncpy(str, unicoo+i*MED_TAILLE_PNOM, MED_TAILLE_PNOM);
00199         str[MED_TAILLE_PNOM] = '\0';
00200         fprintf(stdout, " %s ", str);
00201     };
00202 
00203     fprintf(stdout, "\n- Coordonnees des noeuds : \n");
00204     for (i=0; i<nnoe*mdim; i++) {
00205         fprintf(stdout, " %f ", *(coo+i));
00206     };
00207 
00208     fprintf(stdout, "\n- Numeros des familles des noeuds : \n");
00209     for (i=0; i<nnoe; i++) {
00210         fprintf(stdout, " %d ", *(fam+i));
00211     };
00212     fprintf(stdout, "\n");
00213 
00214     if (nnoe) {
00215         free(coo);
00216         free(fam);
00217     };
00218     return(0);
00219 }
00220 
00221 int grid(med_idt fid, int numero, med_grid_type theType, med_mode_switch mode_coo) {
00222     switch (theType) {
00223         case MED_CARTESIAN : {
00224             fprintf(stdout, "- Type de la grille : MED_CARTESIAN\n");
00225             return(grid_cartesian_or_polar(fid, numero, mode_coo));
00226         };
00227         case MED_POLAR : {
00228             fprintf(stdout, "- Type de la grille : MED_POLAR\n");
00229             return(grid_cartesian_or_polar(fid, numero, mode_coo));
00230         };
00231         case MED_BODY_FITTED : {
00232             fprintf(stdout, "- Type de la grille : MED_BODY_FITTED\n");
00233             return(grid_body_fitted(fid, numero, mode_coo));
00234         };
00235         default : {
00236             fprintf(stderr, ">> ERREUR : type de maillage inconnu\n");
00237             return(EXIT_FAILURE);
00238         };
00239     };
00240 }
00241 
00242 /******************************************************************************
00243  * DUMP D'UN FICHIER MED  : NOEUDS,
00244  * ELEMENTS, FAMILLES, EQUIVALENCES, CHAMPS DE RESULTATS
00245  *****************************************************************************/
00246 
00247 int main (int argc, char **argv)
00248 {
00249   med_err ret = 0;
00250   med_idt fid;
00251   int i,j,k,l,kp;
00252   int numero;
00253   char message[200];
00254   /* nombre d'objets MED */
00255   char nom_universel[MED_TAILLE_LNOM+1];
00256   med_int long_fichier_en_tete; 
00257   char *fichier_en_tete;
00258   char version_hdf[10];
00259   char version_med[10];
00260   med_int nmaa,mdim,nnoe;
00261   //med_int nmai[MED_NBR_GEOMETRIE_MAILLE],nfac[MED_NBR_GEOMETRIE_FACE];
00262   //med_int nare[MED_NBR_GEOMETRIE_ARETE];
00263   /* nom du maillage */
00264   char nommaa[MED_TAILLE_NOM+1];
00265   /* noeuds */
00266   med_float *coo;
00267   char nomcoo[3*MED_TAILLE_PNOM+1];
00268   char unicoo[3*MED_TAILLE_PNOM+1];
00269   char *nomnoe;
00270   med_int *numnoe;
00271   med_int *nufano; 
00272   med_repere rep;
00273   med_booleen inonoe,inunoe;
00274   med_mode_switch mode_coo;
00275   char str[MED_TAILLE_PNOM+1];
00276   /* elements */
00277   med_int nsup;
00278   med_int edim;
00279   med_int taille;
00280   med_int *connectivite;
00281   char *nomele;
00282   med_int *numele;
00283   med_int *nufael;
00284   med_booleen inoele, inuele;
00285   med_connectivite typ_con;
00286   med_geometrie_element typgeo;
00287   med_geometrie_element typmai[MED_NBR_GEOMETRIE_MAILLE] = {MED_POINT1,MED_SEG2, 
00288                                                    MED_SEG3,MED_TRIA3,
00289                                                    MED_TRIA6,MED_QUAD4,
00290                                                    MED_QUAD8,MED_TETRA4,
00291                                                    MED_TETRA10,MED_HEXA8,
00292                                                    MED_HEXA20,MED_PENTA6,
00293                                                    MED_PENTA15,MED_PYRA5,
00294                                                    MED_PYRA13};
00295   med_int desmai[MED_NBR_GEOMETRIE_MAILLE] = {0,2,3,3,3,4,4,4,4,6,6,5,5,5,5};
00296   med_int nmailles[MED_NBR_GEOMETRIE_MAILLE];
00297   char nommai[MED_NBR_GEOMETRIE_MAILLE] [MED_TAILLE_NOM+1] = {"MED_POINT1",
00298                                                           "MED_SEG2", 
00299                                                           "MED_SEG3",
00300                                                           "MED_TRIA3",
00301                                                           "MED_TRIA6",
00302                                                           "MED_QUAD4",
00303                                                           "MED_QUAD8",
00304                                                           "MED_TETRA4",
00305                                                           "MED_TETRA10",
00306                                                           "MED_HEXA8",
00307                                                           "MED_HEXA20",
00308                                                           "MED_PENTA6",
00309                                                           "MED_PENTA15",
00310                                                           "MED_PYRA5",
00311                                                           "MED_PYRA13"};
00312   med_geometrie_element typfac[MED_NBR_GEOMETRIE_FACE] = {MED_TRIA3,MED_TRIA6,
00313                                                  MED_QUAD4,MED_QUAD8};
00314   med_int desfac[MED_NBR_GEOMETRIE_FACE] = {3,3,4,4};
00315   med_int nfaces[MED_NBR_GEOMETRIE_FACE];
00316   char nomfac[MED_NBR_GEOMETRIE_FACE][MED_TAILLE_NOM+1] = {"MED_TRIA3","MED_TRIA6",
00317                                                        "MED_QUAD4","MED_QUAD8"};
00318   med_geometrie_element typare[MED_NBR_GEOMETRIE_ARETE] = {MED_SEG2,MED_SEG3};
00319   med_int desare[MED_NBR_GEOMETRIE_ARETE] = {2,3};
00320   med_int naretes[MED_NBR_GEOMETRIE_ARETE];
00321   char nomare[MED_NBR_GEOMETRIE_ARETE] [MED_TAILLE_NOM+1] = {"MED_SEG2","MED_SEG3"};
00322   /* familles */
00323   med_int nfam;
00324   med_int natt,ngro;
00325   char *attdes,*gro;
00326   med_int *attval,*attide;
00327   char nomfam[MED_TAILLE_NOM+1];
00328   med_int numfam;
00329   char str1[MED_TAILLE_DESC+1];
00330   char str2[MED_TAILLE_LNOM+1];
00331   /* equivalences */
00332   med_int nequ,ncor;
00333   med_int *cor;
00334   char equ[MED_TAILLE_NOM+1];
00335   char des[MED_TAILLE_DESC+1];
00336   /* champs de resultats */
00337   char *comp;
00338   char *unit;
00339   char nomcha[MED_TAILLE_NOM+1];
00340   char maillage_champ[MED_TAILLE_NOM+1];
00341   med_int ncomp;
00342   med_float *valr;
00343   med_int *vale;
00344   med_type_champ typcha;
00345   med_int ncha;
00346   med_int nval;
00347   int reponse;
00348   int lecture_en_tete_seulement = 0;
00349   med_int npdt;
00350   med_int ngauss,numdt,numo;
00351   med_float dt;
00352   char dtunit[MED_TAILLE_PNOM+1];
00353   char pflnom[MED_TAILLE_NOM+1];
00354   med_int pflsize;
00355   med_int *pflval;
00356   med_int isGrid;
00357   med_grid_type theType;
00358 
00359   /****************************************************************************
00360   *                  TEST DU NOMBRE D'ARGUMENTS                               *
00361   *                  argument 1 = nom du fichier MED                          *
00362   ****************************************************************************/
00363   if (argc != 2 && argc != 5)
00364     {
00365       fprintf(stderr,">> ERREUR : nombre de parametres incorrects \n");
00366       exit(EXIT_FAILURE);
00367     }
00368 
00369   /****************************************************************************
00370   *                      OUVERTURE DU FICHIER EN LECTURE                      *
00371   ****************************************************************************/
00372   fid = MEDouvrir(argv[1],MED_LECT);
00373   if (fid < 0)
00374     {
00375       fprintf(stderr,">> ERREUR : ouverture du fichier %s \n",argv[1]);
00376       exit(EXIT_FAILURE);
00377     }
00378 
00379 
00380   /****************************************************************************
00381   *                     QUESTIONS PRELIMINAIRES                               *
00382   *    1. Mode d'affichage des coordonnees (entrelace ou non) ?               *
00383   *    2. Connectivite des elements (nodale ou descendante)                   *
00384   ****************************************************************************/
00385   fprintf(stdout,"\n >>>>>> DUMP DU FICHIER %s >>>>>>\n",argv[1]);
00386 
00387   /* en-tete du fichier (presence optionnelle) */
00388   long_fichier_en_tete = MEDlFichDes(fid);
00389   if (long_fichier_en_tete > 0)
00390     {
00391       fichier_en_tete = (char *) malloc(sizeof(char)*(long_fichier_en_tete+1));
00392       ret = MEDfichEntete(fid,MED_FICH_DES,fichier_en_tete);
00393       if (ret < 0)
00394         {
00395           fprintf(stderr,">> ERREUR : lecture de l'en-tete du fichier \n");
00396           exit(EXIT_FAILURE);
00397         }      
00398       fprintf(stdout,"- En-tete du fichier : %s \n",fichier_en_tete);
00399       free(fichier_en_tete);
00400     }
00401   /* versions hdf et med */
00402   ret = MEDfichEntete(fid,MED_HDF_VERSION,version_hdf);
00403   if (ret < 0)
00404     {
00405       fprintf(stderr,">> ERREUR : lecture du numero de version de HDF \n");
00406       exit(EXIT_FAILURE);
00407     }      
00408   ret = MEDfichEntete(fid,MED_VERSION,version_med);
00409   if (ret < 0)
00410     {
00411       fprintf(stderr,">> ERREUR : lecture du numero de version de MED \n");
00412       exit(EXIT_FAILURE);
00413     }     
00414   fprintf(stdout,"- Version de HDF utilisee : %s \n",version_hdf);
00415   fprintf(stdout,"- Version de MED utilisee : %s \n",version_med);
00416 
00417   if (argc == 2)
00418     {
00419       fprintf(stdout,"(*****************)\n");
00420       fprintf(stdout,"(* PARAMETRAGE : *)\n");
00421       fprintf(stdout,"(*****************)\n");
00422       fprintf(stdout,"- Mode d'affichage des coordonnées des noeuds ? \n");
00423       fprintf(stdout,"  1. Mode entrelacé : taper 1 \n"); 
00424       fprintf(stdout,"  2. Mode non entrelacé : taper 2 \n");
00425       reponse = 0;
00426       do
00427         {
00428           fprintf(stdout,"  Reponse : ");
00429           scanf("%d",&reponse);
00430         }
00431       while (reponse != 1 && reponse != 2);
00432       if (reponse == 1)
00433         mode_coo = MED_FULL_INTERLACE;
00434       else
00435         mode_coo = MED_NO_INTERLACE;
00436       
00437       fprintf(stdout,"- Connectivité des éléments ? \n");
00438       fprintf(stdout,"  1. Nodale : taper 1 \n"); 
00439       fprintf(stdout,"  2. Descendante : taper 2 \n");
00440       reponse = 0;
00441       do
00442         {
00443           fprintf(stdout,"  Reponse : ");
00444           scanf("%d",&reponse);
00445         }
00446       while (reponse != 1 && reponse != 2);
00447       if (reponse == 1)
00448         typ_con = MED_NOD;
00449       else
00450         typ_con = MED_DESC;
00451     }
00452   else
00453       {
00454         if (! strcmp(argv[3],"NODALE"))
00455           typ_con = MED_NOD;
00456         if (! strcmp(argv[3],"DESCENDANTE"))    
00457           typ_con = MED_DESC;
00458         
00459         if (!strcmp(argv[4],"NO_INTERLACE"))
00460           mode_coo = MED_NO_INTERLACE;
00461         if (!strcmp(argv[4],"FULL_INTERLACE"))
00462           mode_coo = MED_FULL_INTERLACE;
00463         if (! strcmp(argv[4],"LECTURE_EN_TETE_SEULEMENT"))
00464           lecture_en_tete_seulement = 1;
00465 
00466       }
00467 
00468   /****************************************************************************
00469   *                      QUEL MAILLAGE LIRE                                   *
00470   ****************************************************************************/
00471   nmaa = MEDnMaa(fid);
00472   if (nmaa < 0)
00473     {
00474       fprintf(stderr,">> ERREUR : lecture du nombre de maillages \n");
00475       exit(EXIT_FAILURE);
00476     }
00477   
00478   /* Quel maillage lire ? */
00479   if (argc == 2)
00480     {
00481       fprintf(stdout,"- Il y a %d maillages dans ce fichier \n",nmaa);
00482       fprintf(stdout,"  Lequel voulez-vous lire (1|2|3|...|n) ?\n");
00483       do
00484         {
00485           fprintf(stdout,"  Reponse : ");
00486           scanf("%d",&numero);
00487         }
00488       while (numero > nmaa || numero <= 0);
00489     }
00490   else
00491     {
00492       numero = atoi(argv[2]);
00493       if (numero > nmaa || numero  <= 0)
00494         {
00495           fprintf(stderr,">> ERREUR : il y a %d maillages dans ce fichier  \n",
00496                   nmaa);
00497           exit(EXIT_FAILURE);
00498         }
00499     }
00500 
00501 /*****************************************************************************
00502  *       QUELLE SORTE DE MAILLAGE : GRILLE OU PAS                            *
00503  *****************************************************************************/
00504 
00505     fprintf(stdout,"\n(**************************************************)\n");
00506     fprintf(stdout,"(* MAILLAGE STRUCTURE (GRILLE) OU NON STRUCTURE : *)\n");
00507     fprintf(stdout,"(**************************************************)\n");
00508 
00509     /* lecture de la sorte de maillage : structure ou pas */
00510     ret = MEDgridInfo(fid, numero, &isGrid, &theType);
00511     if (ret < 0) {
00512         fprintf(stderr, ">> ERREUR : lecture de la sorte de maillage (structure ou pas)\n");
00513         exit(EXIT_FAILURE);
00514     };
00515     fprintf(stdout, "- Sorte de maillage : %s\n", isGrid? "structure (grille)": "non structure");
00516     if (isGrid) {
00517         ret = grid(fid, numero, theType, mode_coo);
00518         if (ret == 0) {
00519             ret = MEDfermer(fid);
00520             if (ret == 0) {
00521                 fprintf(stdout, "\n >>>>>> FIN DU DUMP DU FICHIER %s >>>>>>\n", argv[1]);
00522             } else {
00523                 fprintf(stderr, ">> ERREUR : erreur a la fermeture du fichier %s\n", argv[1]);
00524             };
00525         };
00526         if (ret == 0) {
00527             return(0);
00528         } else {
00529             exit(EXIT_FAILURE);
00530         };
00531     };
00532 
00533   /****************************************************************************
00534   *                       NOMBRES D'OBJETS MED                                *
00535   ****************************************************************************/
00536   fprintf(stdout,"\n(****************************)\n");
00537   fprintf(stdout,"(* INFORMATIONS GENERALES : *)\n");
00538   fprintf(stdout,"(****************************)\n");
00539 
00540   /* lecture du nom et de la dimension du maillage */
00541   ret = MEDmaaInfo(fid,numero,nommaa,&mdim);
00542   if (ret < 0)
00543     {
00544       fprintf(stderr,">> ERREUR : lecture du nom du maillage \n");
00545       exit(EXIT_FAILURE);
00546     }
00547   fprintf(stdout,"- Nom du maillage : <<%s>>\n",nommaa);
00548   fprintf(stdout,"- Dimension du maillage : %d\n",mdim);
00549 
00550   /* lecture du nom universel (presence optionnelle) */
00551  ret = MEDunvLire(fid,nommaa,nom_universel);
00552  if (ret > 0)
00553    fprintf(stdout,"- Nom universel du maillage : %s \n",nom_universel);
00554  else
00555    fprintf(stdout,"- Pas de nom universel \n");
00556   
00557       
00558   /* Combien de noeuds ? */
00559   nnoe = MEDnEntMaa(fid,nommaa,MED_COOR,MED_NOEUD,(med_geometrie_element)0,(med_connectivite)0);
00560   if (nnoe < 0)
00561     {
00562       fprintf(stderr,">> ERREUR : lecture du nombre de noeuds (via MEDnEntMaa) \n");
00563       exit(EXIT_FAILURE);
00564     }
00565   fprintf(stdout,"- Nombre de noeuds : %d \n",nnoe);
00566 
00567   /* Combien de mailles, faces ou aretes ? */
00568   for (i=0;i<MED_NBR_GEOMETRIE_MAILLE;i++)
00569     {
00570       nmailles[i] = MEDnEntMaa(fid,nommaa,MED_CONN,MED_MAILLE,typmai[i],
00571                                typ_con);
00572       if (nmailles[i] < 0)
00573         {
00574           fprintf(stderr,">> ERREUR : lecture du nombre de mailles \n");
00575           exit(EXIT_FAILURE);
00576         }
00577       fprintf (stdout,"- Nombre de mailles de type %s : %d \n",nommai[i],nmailles[i]);
00578     }
00579 
00580   for (i=0;i<MED_NBR_GEOMETRIE_FACE;i++)
00581     {
00582       nfaces[i] = MEDnEntMaa(fid,nommaa,MED_CONN,MED_FACE,typfac[i],
00583                              typ_con);
00584       if (nfaces[i] < 0)
00585         {
00586           fprintf(stderr,">> ERREUR : lecture du nombre de faces \n");
00587           exit(EXIT_FAILURE);
00588         }
00589       fprintf (stdout,"- Nombre de faces de type %s : %d \n",nomfac[i],nfaces[i]);
00590     }    
00591 
00592   for (i=0;i<MED_NBR_GEOMETRIE_ARETE;i++)
00593     {
00594       naretes[i] = MEDnEntMaa(fid,nommaa,MED_CONN,MED_ARETE,typare[i],
00595                               typ_con); 
00596       if (naretes[i] < 0)
00597         {
00598           fprintf(stderr,">> ERREUR : lecture du nombre d'aretes \n");
00599           exit(EXIT_FAILURE);
00600         }
00601       fprintf (stdout,"- Nombre d'aretes de type %s : %d \n",nomare[i],naretes[i]);
00602     }
00603 
00604   /* nombre de familles */
00605   nfam = MEDnFam(fid,nommaa,0,(med_dim_famille)0);
00606   if (nfam < 0)
00607     {
00608       fprintf(stderr,">> ERREUR : lecture du nombre de familles \n");
00609       exit(EXIT_FAILURE);
00610     }   
00611   fprintf(stdout,"- Nombre de familles : %d \n",nfam);
00612 
00613   /* combien d'equivalences dans le fichier */
00614   nequ = MEDnEquiv(fid,nommaa);
00615   if (nequ < 0)
00616     {
00617       fprintf(stderr,">> ERREUR : lecture du nombre d'equivalences \n");
00618       exit(EXIT_FAILURE);
00619     }   
00620     fprintf(stdout,"- Nombre d'equivalences : %d \n",nequ);
00621 
00622   /* combien de champs dans le fichier */
00623   ncha = MEDnChamp(fid,0);
00624   if (ncha < 0)
00625     {
00626       fprintf(stderr,">> ERREUR : lecture du nombre de champs \n");
00627       exit(EXIT_FAILURE);
00628     }   
00629   fprintf(stdout,"- Nombre de champs : %d \n",ncha);
00630 
00631   /* Doit-on s'arreter ? */
00632   if (lecture_en_tete_seulement)
00633     {
00634       ret = MEDfermer(fid);
00635       if (ret == 0)
00636         {
00637           fprintf(stdout,"\n >>>>>> FIN DU DUMP DU FICHIER %s >>>>>>\n",argv[1]);
00638           return 0;
00639         }
00640       else
00641         {
00642           fprintf(stderr,">> ERREUR : fermeture du fichier %s  \n",argv[1]);
00643           exit(EXIT_FAILURE);
00644         }
00645     }
00646 
00647   /****************************************************************************
00648   *                       LECTURE DES NOEUDS                                  *
00649   ****************************************************************************/
00650   fprintf(stdout,"\n(************************)\n");
00651   fprintf(stdout,"(* NOEUDS DU MAILLAGE : *)\n");
00652   fprintf(stdout,"(************************)\n");
00653 
00654   /* Allocations memoires */
00655   /* table des coordonnees 
00656      profil : (dimension * nombre de noeuds ) */
00657   coo = (med_float*) malloc(sizeof(med_float)*nnoe*mdim);
00658   /* table  des numeros, des numeros de familles des noeuds
00659      profil : (nombre de noeuds) */
00660   numnoe = (med_int*) malloc(sizeof(med_int)*nnoe);
00661   nufano = (med_int*) malloc(sizeof(med_int)*nnoe);
00662   /* table des noms des noeuds 
00663      profil : (nnoe*MED_TAILLE_PNOM+1) */
00664   nomnoe = (char*) malloc(MED_TAILLE_PNOM*nnoe+1);
00665 
00666   /* lecture des noeuds : 
00667      - coordonnees
00668      - noms (optionnel dans un fichier MED) 
00669      - numeros (optionnel dans un fichier MED) 
00670      - numeros des familles */
00671   ret = MEDnoeudsLire(fid,nommaa,mdim,coo,mode_coo,&rep,
00672                       nomcoo,unicoo,nomnoe,&inonoe,numnoe,&inunoe,
00673                       nufano,nnoe);
00674   if (ret < 0)
00675     strcpy(message,">> ERREUR : lecture des noeuds \n");
00676 
00677   /* affichage des resultats */
00678   if (ret == 0)
00679     { 
00680       fprintf(stdout,"- Type de repere des coordonnees : %d \n",rep);
00681       fprintf(stdout,"- Nom des coordonnees : \n");
00682       for (i=0;i<mdim;i++)
00683         {
00684           strncpy(str,nomcoo+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
00685           str[MED_TAILLE_PNOM] = '\0';
00686           fprintf(stdout," %s ",str);
00687         }
00688       fprintf(stdout,"\n- Unites des coordonnees : \n");
00689       for (i=0;i<mdim;i++)
00690         {
00691           strncpy(str,unicoo+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
00692           str[MED_TAILLE_PNOM] = '\0';
00693           fprintf(stdout," %s ",str);
00694         }     
00695       fprintf(stdout,"\n- Coordonnees des noeuds : \n");
00696       for (i=0;i<nnoe*mdim;i++)
00697         fprintf(stdout," %f ",*(coo+i));
00698       if (inonoe)
00699         {
00700           fprintf(stdout,"\n- Noms des noeuds : \n");
00701           for (i=0;i<nnoe;i++)
00702             {
00703               strncpy(str,nomnoe+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
00704               str[MED_TAILLE_PNOM] = '\0';
00705               fprintf(stdout," %s ",str);
00706             }
00707         }
00708       if (inunoe)
00709         {
00710           fprintf(stdout,"\n- Numeros des noeuds : \n");
00711           for (i=0;i<nnoe;i++)
00712               fprintf(stdout," %d ",*(numnoe+i));
00713         }
00714       fprintf(stdout,"\n- Numeros des familles des noeuds : \n");
00715       for (i=0;i<nnoe;i++)
00716         fprintf(stdout," %d ",*(nufano+i));
00717       fprintf(stdout,"\n");
00718     }
00719 
00720   /* liberation memoire */
00721   free(coo);
00722   free(nomnoe);
00723   free(numnoe);
00724   free(nufano);
00725 
00726   /****************************************************************************
00727   *                       LECTURE DES ELEMENTS                                *
00728   ****************************************************************************/
00729   fprintf(stdout,"\n(**************************)\n");
00730   fprintf(stdout,"(* ELEMENTS DU MAILLAGE : *)\n");
00731   fprintf(stdout,"(**************************)");
00732   /* Lecture des connectivites, noms, numeros des mailles */
00733   if (ret == 0)
00734     for (i=0;i<MED_NBR_GEOMETRIE_MAILLE;i++)
00735       {
00736         if (nmailles[i] > 0 && ret == 0)
00737           {
00738             /* dimension de la maille */
00739             edim = typmai[i] / 100;
00740             nsup = 0;
00741             if (mdim  == 2 || mdim == 3)
00742               if (edim == 1)
00743                 nsup = 1;
00744             if (mdim == 3)
00745               if (edim == 2)
00746                 nsup = 1;
00747             switch(typ_con)
00748               {
00749               case MED_NOD :
00750                 taille = nsup+typmai[i]%100;
00751                 break;
00752                 
00753               case MED_DESC :
00754                 taille = nsup+desmai[i];
00755                 break;
00756                 
00757               default :
00758                 ret = -1;
00759               }
00760             
00761             /* allocation memoire */
00762             connectivite = (med_int*)malloc(sizeof(med_int)*
00763                                             taille*nmailles[i]);
00764             nomele = (char*)malloc(sizeof(char)*MED_TAILLE_PNOM*
00765                                    nmailles[i]+1);
00766             numele = (med_int*)malloc(sizeof(med_int)*
00767                                       nmailles[i]);
00768             nufael = (med_int*)malloc(sizeof(med_int)*
00769                                       nmailles[i]);
00770             
00771             /* lecture des données */
00772             ret = MEDelementsLire(fid,nommaa,mdim,connectivite,mode_coo,
00773                                   nomele,&inoele,numele,&inuele,nufael,
00774                                   nmailles[i],MED_MAILLE,typmai[i],
00775                                   typ_con);
00776             if (ret < 0)
00777               strcpy(message,">> ERREUR : lecture des mailles \n");
00778             
00779             /* affichage des resultats */
00780             if (ret == 0)
00781               {
00782                 fprintf(stdout,"\n\n- Mailles de type %s : ", nommai[i]);
00783                 fprintf(stdout,"\n  - Connectivité : \n");
00784                 for (j=0;j<nmailles[i]*taille;j++)
00785                   fprintf(stdout," %d ",*(connectivite+j));
00786                 if (inoele)
00787                   {
00788                     fprintf(stdout,"\n  - Noms : \n");
00789                     for (j=0;j<nmailles[i];j++)
00790                       {
00791                         fprintf(stdout," %d ",*(connectivite+j));
00792                         strncpy(str,nomele+j*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
00793                         str[MED_TAILLE_PNOM] = '\0';
00794                         fprintf(stdout," %s ",str);
00795                       }
00796                   }
00797                 if (inuele)
00798                   {
00799                     fprintf(stdout,"\n  - Numeros :\n");
00800                     for (j=0;j<nmailles[i];j++)
00801                       fprintf(stdout," %d ",*(numele+j));
00802                   }
00803                 fprintf(stdout,"\n  - Numéros de familles : \n");
00804                 for (j=0;j<nmailles[i];j++)
00805                   fprintf(stdout," %d ",*(nufael+j));
00806               }
00807                 
00808             /* liberation memoire */
00809             free(connectivite);
00810             free(nomele);
00811             free(numele);
00812             free(nufael);
00813           }
00814       }
00815 
00816   if (ret == 0)
00817     for (i=0;i<MED_NBR_GEOMETRIE_FACE;i++)
00818       {
00819         if (nfaces[i] > 0 && ret == 0)
00820           {
00821             /* dimension de la face */
00822             edim = typfac[i] / 100;
00823             nsup = 0;
00824             if (mdim  == 2 || mdim == 3)
00825               if (edim == 1)
00826                 nsup = 1;
00827             if (mdim == 3)
00828               if (edim == 2)
00829                 nsup = 1;
00830             switch(typ_con)
00831               {
00832               case MED_NOD :
00833                 taille = nsup+typfac[i]%100;
00834                 break;
00835                 
00836               case MED_DESC :
00837                 taille = nsup+desfac[i];
00838                 break;
00839                 
00840               default :
00841                 ret = -1;
00842               }
00843             
00844             /* allocation memoire */
00845             connectivite = (med_int*)malloc(sizeof(med_int)*
00846                                             taille*nfaces[i]);
00847             nomele = (char*)malloc(sizeof(char)*MED_TAILLE_PNOM*
00848                                    nfaces[i]+1);
00849             numele = (med_int*)malloc(sizeof(med_int)*
00850                                       nfaces[i]);
00851             nufael = (med_int*)malloc(sizeof(med_int)*
00852                                       nfaces[i]);
00853             
00854             /* lecture des données */
00855             ret = MEDelementsLire(fid,nommaa,mdim,connectivite,mode_coo,
00856                                   nomele,&inoele,numele,&inuele,nufael,
00857                                   nfaces[i],MED_FACE,typfac[i],
00858                                   typ_con);
00859             if (ret < 0)
00860               strcpy(message,">> ERREUR : lecture des faces \n");
00861             
00862             /* affichage des resultats */
00863             if (ret == 0)
00864               {
00865                 fprintf(stdout,"\n- Faces de type %s : ", nomfac[i]);
00866                 fprintf(stdout,"\n  - Connectivité : \n");
00867                 for (j=0;j<nfaces[i]*taille;j++)
00868                   fprintf(stdout," %d ",*(connectivite+j));
00869                 if (inoele)
00870                   {
00871                     fprintf(stdout,"\n  - Noms : \n");
00872                     for (j=0;j<nfaces[i];j++)
00873                       {
00874                         fprintf(stdout," %d ",*(connectivite+j));
00875                         strncpy(str,nomele+j*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
00876                         str[MED_TAILLE_PNOM] = '\0';
00877                         fprintf(stdout," %s ",str);
00878                       }
00879                   }
00880                 if (inuele)
00881                   {
00882                     fprintf(stdout,"\n  - Numeros :\n");
00883                     for (j=0;j<nfaces[i];j++)
00884                       fprintf(stdout," %d ",*(numele+j));
00885                   }
00886                 fprintf(stdout,"\n  - Numéros de familles : \n");
00887                 for (j=0;j<nfaces[i];j++)
00888                   fprintf(stdout," %d ",*(nufael+j));
00889               }
00890                 
00891             /* liberation memoire */
00892             free(connectivite);
00893             free(nomele);
00894             free(numele);
00895             free(nufael);
00896           }
00897     }    
00898 
00899   if (ret == 0)
00900     for (i=0;i<MED_NBR_GEOMETRIE_ARETE;i++)
00901       {
00902         if (naretes[i] > 0 && ret == 0)
00903           {
00904             /* dimension de l'arete  */
00905             edim = typare[i] / 100;
00906             nsup = 0;
00907             if (mdim  == 2 || mdim == 3)
00908               if (edim == 1)
00909                 nsup = 1;
00910             if (mdim == 3)
00911               if (edim == 2)
00912                 nsup = 1;
00913             switch(typ_con)
00914               {
00915               case MED_NOD :
00916                 taille = nsup+typare[i]%100;
00917                 break;
00918                 
00919               case MED_DESC :
00920                 taille = nsup+desare[i];
00921                 break;
00922                 
00923               default :
00924                 ret = -1;
00925               }
00926             
00927             /* allocation memoire */
00928             connectivite = (med_int*)malloc(sizeof(med_int)*
00929                                             taille*naretes[i]);
00930             nomele = (char*)malloc(sizeof(char)*MED_TAILLE_PNOM*
00931                                    naretes[i]+1);
00932             numele = (med_int*)malloc(sizeof(med_int)*
00933                                       naretes[i]);
00934             nufael = (med_int*)malloc(sizeof(med_int)*
00935                                       naretes[i]);
00936             
00937             /* lecture des données */
00938             ret = MEDelementsLire(fid,nommaa,mdim,connectivite,mode_coo,
00939                                   nomele,&inoele,numele,&inuele,nufael,
00940                                   naretes[i],MED_ARETE,typare[i],
00941                                   typ_con);
00942             if (ret < 0)
00943               strcpy(message,">> ERREUR : lecture des aretes \n");
00944             
00945             /* affichage des resultats */
00946             if (ret == 0)
00947               {
00948                 fprintf(stdout,"\n- Aretes de type %s : ", nomare[i]);
00949                 fprintf(stdout,"\n  - Connectivité : \n");
00950                 for (j=0;j<naretes[i]*taille;j++)
00951                   fprintf(stdout," %d ",*(connectivite+j));
00952                 if (inoele)
00953                   {
00954                     fprintf(stdout,"\n  - Noms : \n");
00955                     for (j=0;j<naretes[i];j++)
00956                       {
00957                         fprintf(stdout," %d ",*(connectivite+j));
00958                         strncpy(str,nomele+j*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
00959                         str[MED_TAILLE_PNOM] = '\0';
00960                         fprintf(stdout," %s ",str);
00961                       }
00962                   }
00963                 if (inuele)
00964                   {
00965                     fprintf(stdout,"\n  - Numeros :\n");
00966                     for (j=0;j<naretes[i];j++)
00967                       fprintf(stdout," %d ",*(numele+j));
00968                   }
00969                 fprintf(stdout,"\n  - Numéros de familles : \n");
00970                 for (j=0;j<naretes[i];j++)
00971                   fprintf(stdout," %d ",*(nufael+j));
00972               }
00973                 
00974             /* liberation memoire */
00975             free(connectivite);
00976             free(nomele);
00977             free(numele);
00978             free(nufael);
00979           }
00980       }
00981   
00982   /****************************************************************************
00983   *                       LECTURE DES FAMILLES                                *
00984   ****************************************************************************/
00985   printf("\n(*************************)\n");
00986   printf("(* FAMILLES DU MAILLAGE : *)\n");
00987   printf("(*************************)\n");
00988   if (ret == 0)
00989     for (i=0;i<nfam;i++)
00990       {
00991         
00992         /* nombre de groupes */
00993         ngro = MEDnFam(fid,nommaa,i+1,MED_GROUPE);
00994         if (ngro < 0)  
00995           {
00996             ret = -1;
00997             strcpy(message,
00998                    ">> ERREUR : lecture du nombre de groupes d'une famille \n");
00999           }
01000         
01001         /* nombre d'attributs */
01002         if (ret == 0)
01003           {
01004             natt = MEDnFam(fid,nommaa,i+1,MED_ATTR);
01005             if (natt < 0)
01006               {
01007                 ret = -1;
01008                 strcpy(message,
01009                    ">> ERREUR : lecture du nombre d'attributs d'une famille\n");
01010               }
01011           }
01012 
01013         if (ret == 0)
01014           fprintf(stdout,"- Famille %d a %d attributs et %d groupes \n",i+1,natt,ngro); 
01015 
01016         /* nom,numero,attributs,groupes */
01017         if (ret == 0)
01018           {
01019             attide = (med_int*) malloc(sizeof(med_int)*natt);
01020             attval = (med_int*) malloc(sizeof(med_int)*natt);       
01021             attdes = (char *) malloc(MED_TAILLE_DESC*natt+1);
01022             gro = (char*) malloc(MED_TAILLE_LNOM*ngro+1);
01023             ret = MEDfamInfo(fid,nommaa,i+1,nomfam,&numfam,attide,attval,
01024                              attdes,&natt,gro,&ngro);
01025             fprintf(stdout,"  - Famille de nom %s et de numero %d : \n",nomfam,numfam);
01026             fprintf(stdout,"  - Attributs : \n");
01027             for (j=0;j<natt;j++)
01028               {
01029                 strncpy(str1,attdes+j*MED_TAILLE_DESC,MED_TAILLE_DESC);
01030                 str1[MED_TAILLE_DESC] = '\0';
01031                 fprintf(stdout,"   ide = %d - val = %d - des = %s\n",*(attide+j),
01032                        *(attval+j),str1);
01033               }
01034             free(attide);
01035             free(attval);
01036             free(attdes);
01037             fprintf(stdout,"  - Groupes :\n");
01038             for (j=0;j<ngro;j++)
01039               {
01040                 strncpy(str2,gro+j*MED_TAILLE_LNOM,MED_TAILLE_LNOM);
01041                 str2[MED_TAILLE_LNOM] = '\0';
01042                 fprintf(stdout,"   gro = %s\n",str2);
01043               }
01044             free(gro);
01045           }
01046       }
01047 
01048   /****************************************************************************
01049   *                       LECTURE DES EQUIVALENCES                            *
01050   ****************************************************************************/
01051   fprintf(stdout,"\n(******************************)\n");
01052   fprintf(stdout,"(* EQUIVALENCES DU MAILLAGE : *)\n");
01053   fprintf(stdout,"(******************************)\n");
01054 
01055   /* lecture de toutes les equivalences associes a nommaa */
01056   if (ret == 0)
01057     for (i = 0;i<nequ;i++)
01058       {
01059         fprintf(stdout,"- Equivalence numero : %d ",i+1);
01060 
01061         /* lecture des infos sur l'equivalence */
01062         ret = MEDequivInfo(fid,nommaa,i+1,equ,des);
01063         if (ret == 0)
01064           {
01065             fprintf(stdout,"\n  - Nom de l'equivalence: %s \n",equ);
01066             fprintf(stdout,"\n  - Description de l'equivalence : %s \n",des);
01067           }
01068         else
01069           strcpy(message,">> ERREUR : lecture informations sur equivalence\n");
01070 
01071         /* lecture des correspondances sur les differents types d'entites */
01072         if (ret == 0)
01073           {
01074             /* les noeuds */
01075             if ((ncor = MEDnCorres(fid,nommaa,equ,MED_NOEUD,(med_geometrie_element)0)) < 0)
01076               {
01077                 ret = -1;
01078                 strcpy(message,">> ERREUR : lecture nombre de correspondances\n");
01079               }
01080             else
01081               fprintf(stdout,"\n  - Il y a %d correspondances sur les noeuds \n",ncor);
01082             if (ncor > 0)
01083               {
01084                 cor = (med_int*) malloc(sizeof(med_int)*ncor*2);
01085                 ret = MEDequivLire(fid,nommaa,equ,cor,ncor,MED_NOEUD,(med_geometrie_element)0);
01086                 if (ret == 0)
01087                   for (j=0;j<ncor;j++)
01088                     fprintf(stdout,"\n  - Correspondance %d : %d et %d \n",j+1,*(cor+2*j),
01089                            *(cor+2*j+1));
01090                 else
01091                    strcpy(message,">> ERREUR : lecture des correspondances\n");
01092                 free(cor);
01093               }
01094             
01095             /* sur les mailles : on ne prend pas en compte les mailles 3D */
01096             if (ret ==0)
01097               for (j=0;j<NBR_MAILLE_EQU;j++)
01098                 {
01099                   if ((ncor = MEDnCorres(fid,nommaa,equ,MED_MAILLE,typmai[j])) < 0)
01100                     {
01101                       ret = -1;
01102                        strcpy(message,
01103                               ">> ERREUR : lecture informations sur nombre de correspondances \n");
01104                     }
01105                   else
01106                     fprintf(stdout,"\n  - Il y a %d correspondances sur les mailles %s \n",ncor,
01107                            nommai[j]);
01108                   if (ncor > 0)
01109                     {
01110                       cor = (med_int*) malloc(sizeof(med_int)*ncor*2);
01111                       ret = MEDequivLire(fid,nommaa,equ,cor,ncor,MED_MAILLE,
01112                                          typmai[j]);
01113                       if (ret == 0)
01114                         for (k=0;k<ncor;k++)
01115                           fprintf(stdout,"\n  - Correspondance %d : %d et %d \n",k+1,*(cor+2*k),
01116                                  *(cor+2*k+1));
01117                       else
01118                          strcpy(message,">> ERREUR : correspondances\n");
01119                       free(cor);
01120                     }
01121                 }
01122 
01123             /* sur les faces */
01124             if (ret == 0)
01125               for (j=0;j<MED_NBR_GEOMETRIE_FACE;j++)
01126                 {
01127                   if ((ncor = MEDnCorres(fid,nommaa,equ,MED_FACE,typfac[j])) < 0)
01128                     {
01129                       ret = -1;
01130                       strcpy(message,">> ERREUR : informations sur correspondances \n");
01131                     }
01132                   else
01133                     fprintf(stdout,"\n  - Il y a %d correspondances sur les faces %s\n",ncor,
01134                            nomfac[j]);
01135                   if (ncor > 0)
01136                     {
01137                       cor = (med_int*) malloc(sizeof(med_int)*ncor*2);
01138                       ret = MEDequivLire(fid,nommaa,equ,cor,ncor,MED_FACE,
01139                                          typfac[j]);
01140                       if (ret < 0)
01141                         strcpy(message,"ERREUR : lecture des equivalences \n");
01142                       else
01143                         for (k=0;k<ncor;k++)
01144                           fprintf(stdout,"\n  - Correspondance %d : %d et %d \n",k+1,*(cor+2*k),
01145                                  *(cor+2*k+1));
01146                       free(cor);
01147                     }
01148                 }
01149             
01150             /*  sur les aretes */
01151             for (j=0;j<MED_NBR_GEOMETRIE_ARETE;j++)
01152               {
01153                 if ((ncor = MEDnCorres(fid,nommaa,equ,MED_ARETE,typare[j])) < 0)
01154                   {
01155                     ret = -1;
01156                     strcpy(message,">> ERREUR : nombre de correspondances \n");
01157                   }
01158                 else
01159                   fprintf(stdout,"\n  - Il y a %d correspondances sur les aretes %s \n",
01160                          ncor,nomare[j]);
01161                 if (ncor > 0)
01162                   {
01163                     cor = (med_int*) malloc(sizeof(med_int)*ncor*2);
01164                     ret = MEDequivLire(fid,nommaa,equ,cor,ncor,MED_ARETE,
01165                                        typare[j]);
01166                     if (ret < 0)
01167                       strcpy(message,">> ERREUR : equivalences \n");
01168                     else
01169                       for (k=0;k<ncor;k++)
01170                         fprintf(stdout,"\n  Correspondance %d : %d et %d \n",k+1,*(cor+2*k),
01171                                *(cor+2*k+1));
01172                     free(cor);
01173                   }
01174               }
01175           }                         
01176       }
01177 
01178   /****************************************************************************
01179   *                       LECTURE DES CHAMPS                                  *
01180   ****************************************************************************/
01181   fprintf(stdout,"\n(************************)\n");
01182   fprintf(stdout,"(* CHAMPS DU MAILLAGE : *)\n");
01183   fprintf(stdout,"(************************)\n");
01184 
01185   if (ret == 0)
01186     for (i=0;i<ncha;i++)
01187       {
01188         fprintf(stdout,"- Champ numero : %d \n",i+1);
01189         
01190         /* combien de composantes */
01191         if ((ncomp = MEDnChamp(fid,i+1)) < 0)
01192           {
01193             ret = -1;
01194             strcpy(message,">> ERREUR : nombre de composants d'un champ\n");
01195           }
01196         
01197         /* allocation memoire de comp et unit*/
01198         if (ret == 0)
01199           {
01200             comp = (char*) malloc(ncomp*MED_TAILLE_PNOM+1);
01201             unit = (char*) malloc(ncomp*MED_TAILLE_PNOM+1);
01202           }
01203 
01204         /* infos sur les champs */
01205         if (ret == 0)
01206           ret = MEDchampInfo(fid,i+1,nomcha,&typcha,comp,unit,ncomp);
01207         if (ret < 0)
01208           strcpy(message,">> ERREUR : information sur les champs \n");
01209 
01210         if (ret == 0) {
01211           fprintf(stdout,"  - Nom du champ : %s de type %d\n",nomcha,typcha);
01212           fprintf(stdout,"  - Nom des composantes : %s\n",comp);
01213           fprintf(stdout,"  - Unites des composantes : %s \n",unit);
01214           free(comp);
01215           free(unit);   
01216         }
01217              
01218               
01219         if (ret == 0)  /* Valeurs sur les noeuds */
01220           {
01221             /* Combien de pas de temps ? */
01222             npdt = MEDnPasdetemps(fid,nomcha,MED_NOEUD,(med_geometrie_element)0);
01223             if (npdt < 0)
01224               ret = -1;
01225             if (ret == -1)
01226               strcpy(message,">> ERREUR : la lecture du nombe de pas de temps");
01227             else
01228               fprintf(stdout,"\n  - Il y a %d pas de temps sur les noeuds \n",npdt);
01229 
01230             /* Lecture des valeurs pour tous les pas de temps */
01231             if (ret == 0)
01232               for (j=0;j<npdt;j++)
01233                 {
01234                   /* Informations sur les pas de temps */
01235                   if (ret == 0)
01236                     ret = MEDpasdetempsInfo(fid,nomcha,MED_NOEUD,(med_geometrie_element)0,
01237                                             j+1, maillage_champ, &ngauss, &numdt,  dtunit, &dt, &numo);
01238 
01239                   if (ret == 0 && (! strcmp(maillage_champ,nommaa)))
01240                     fprintf(stdout,"\n  -> \tPas de Temps n° %4i (%f), N°d'ordre %4i, avec %i pts de gauss\n",
01241                             numdt,dt,numo,ngauss);
01242                   else
01243                     strcpy(message,">> ERREUR : information sur les pas de temps \n");
01244                   
01245                   /* Combien de valeurs a lire ? */
01246                   if (ret == 0 && (! strcmp(maillage_champ,nommaa)))
01247                     {
01248                       if ((nval = MEDnVal(fid,nomcha,MED_NOEUD,(med_geometrie_element)0,numdt,numo)) < 0)
01249                         {
01250                           ret = -1;
01251                           strcpy(message,">> ERREUR : nombre de valeurs d'un champ\n");
01252                         }
01253                       else
01254                         fprintf(stdout,"\n  - Il y a %d valeurs sur les noeuds \n",nval);
01255                     }
01256 
01257                   if (ret == 0 && (! strcmp(maillage_champ,nommaa)))
01258                     {
01259                       if (typcha == MED_REEL64)
01260                         {
01261                           valr = (med_float*) malloc(sizeof(med_float)*ncomp*nval);
01262                           ret = MEDchampLire(fid,nommaa,nomcha,(unsigned char*)valr,mode_coo,MED_ALL,
01263                                              pflnom,MED_NOEUD,(med_geometrie_element)0,numdt,numo);
01264                                              
01265                           if (ret < 0)
01266                             strcpy(message,">> ERREUR : lecture des champs \n");
01267                           else
01268                             for (k=0;k<nval*ncomp;k++)
01269                               fprintf(stdout," %f ",*(valr+k));
01270                           free(valr);
01271                         }
01272                       else
01273                         {
01274                           vale = (med_int*) malloc(sizeof(med_int)*ncomp*nval);
01275                           ret = MEDchampLire(fid,nommaa,nomcha,(unsigned char*)vale,mode_coo,MED_ALL,
01276                                              pflnom,MED_NOEUD,(med_geometrie_element)0,numdt,numo);
01277                           if (ret < 0)
01278                             strcpy(message,">> ERREUR : lecture des champs \n");
01279                           else
01280                             for (k=0;k<nval*ncomp;k++)
01281                               fprintf(stdout," %d ",*(vale+k));
01282                           free(vale);
01283                         }
01284 
01285                       /* Lecture d'un profil eventuel */
01286                       if (strcmp(pflnom,MED_NOPFL) == 0 )
01287                         fprintf(stdout,"\n \t- Pas de profil\n");
01288                       else 
01289                         {
01290                           if ( (pflsize = MEDnValProfil(fid,pflnom)) <0)
01291                             {
01292                               ret = -1;
01293                               strcpy(message,">> ERREUR : lecture de la taille du profil \n");
01294                             }
01295                           else 
01296                             {
01297                               fprintf(stdout,"\n \t- Profil : %s de taille %i\n",pflnom,pflsize);
01298                               pflval = (med_int*) malloc(sizeof(med_int)*pflsize);
01299                               
01300                               if ( (ret = MEDprofilLire(fid,pflval,pflnom)) <0)
01301                                 strcpy(message,">> ERREUR : lecture du profil \n");
01302                               else
01303                                 for (l=0;l<pflsize;l++)
01304                                   fprintf(stdout,"\t%i\n",*(pflval+l));
01305                               
01306                               free(pflval);
01307                             }
01308                         }
01309                     }                             
01310                 }
01311           }
01312 
01313 
01314         if (ret == 0)  /* Valeurs sur les mailles */
01315           {
01316             for (k=0;k<MED_NBR_GEOMETRIE_MAILLE;k++)
01317               {
01318                 typgeo = typmai[k];
01319 
01320                 /* Combien de pas de temps ? */
01321                 npdt = MEDnPasdetemps(fid,nomcha,MED_MAILLE,typgeo);
01322                 if (npdt < 0)
01323                   ret = -1;
01324                 if (ret == -1)
01325                   strcpy(message,">> ERREUR : la lecture du nombe de pas de temps");
01326                 else
01327                   fprintf(stdout,"\n  - Il y a %d pas de temps sur les mailles de type %d \n",npdt,typgeo);
01328 
01329                 /* Lecture des valeurs pour tous les pas de temps */
01330                 if (ret == 0)
01331                   for (j=0;j<npdt;j++)
01332                     {
01333                       /* Informations sur les pas de temps */
01334                       if (ret == 0)
01335                         ret = MEDpasdetempsInfo(fid,nomcha,MED_MAILLE,typgeo,
01336                                                 j+1, maillage_champ, &ngauss, &numdt,  dtunit, &dt, &numo);
01337 
01338                       if (ret == 0 && (! strcmp(maillage_champ,nommaa)))
01339                         fprintf(stdout,"\n  -> \tPas de Temps n° %4i (%f), N°d'ordre %4i, avec %i pts de gauss\n",
01340                                 numdt,dt,numo,ngauss);
01341                       else
01342                         strcpy(message,">> ERREUR : information sur les pas de temps \n");
01343 
01344                       /* Combien de valeurs a lire ? */
01345                       if (ret == 0 && (! strcmp(maillage_champ,nommaa)))
01346                         {
01347                           if ((nval = MEDnVal(fid,nomcha,MED_MAILLE,typgeo,numdt,numo)) < 0)
01348                             {
01349                               ret = -1;
01350                               strcpy(message,">> ERREUR : nombre de valeurs d'un champ\n");
01351                             }
01352                           else
01353                             fprintf(stdout,"\n  - Il y a %d valeurs sur les noeuds \n",nval);
01354                         }
01355 
01356                       if (ret == 0 && (! strcmp(maillage_champ,nommaa)))
01357                         {
01358                           if (typcha == MED_REEL64)
01359                             {
01360                               valr = (med_float*) malloc(sizeof(med_float)*ncomp*nval);
01361                               ret = MEDchampLire(fid,nommaa,nomcha,(unsigned char*)valr,mode_coo,MED_ALL,
01362                                                  pflnom,MED_MAILLE,typgeo,numdt,numo);
01363                               if (ret < 0)
01364                                 strcpy(message,">> ERREUR : lecture des champs \n");
01365                               else
01366                                 for (kp=0;kp<nval*ncomp;kp++)
01367                                   fprintf(stdout," %f ",*(valr+kp));
01368                               free(valr);
01369                             }
01370                           else
01371                             {
01372                               vale = (med_int*) malloc(sizeof(med_int)*ncomp*nval);
01373                               ret = MEDchampLire(fid,nommaa,nomcha,(unsigned char*)vale,mode_coo,MED_ALL,
01374                                                  pflnom,MED_MAILLE,typgeo,numdt,numo);
01375                               if (ret < 0)
01376                                 strcpy(message,">> ERREUR : lecture des champs \n");
01377                               else
01378                                 for (kp=0;kp<nval*ncomp;kp++)
01379                                   fprintf(stdout," %d ",*(vale+kp));
01380                               free(vale);
01381                             }
01382                           
01383                           /* Lecture d'un profil eventuel */
01384                           if (strcmp(pflnom,MED_NOPFL) == 0 )
01385                             fprintf(stdout,"\n \t- Pas de profil\n");
01386                           else 
01387                             {
01388                               if ( (pflsize = MEDnValProfil(fid,pflnom)) <0)
01389                                 {
01390                                   ret = -1;
01391                                   strcpy(message,">> ERREUR : lecture de la taille du profil \n");
01392                                 }
01393                               else 
01394                                 {
01395                                   fprintf(stdout,"\n \t- Profil : %s de taille %i\n",pflnom,pflsize);
01396                                   pflval = (med_int*) malloc(sizeof(med_int)*pflsize);
01397                                   
01398                                   if ( (ret = MEDprofilLire(fid,pflval,pflnom)) <0)
01399                                     strcpy(message,">> ERREUR : lecture du profil \n");
01400                                   else
01401                                     for (l=0;l<pflsize;l++)
01402                                       fprintf(stdout,"\t%i\n",*(pflval+l));
01403                                   
01404                                   free(pflval);
01405                                 }
01406                             }
01407                         }                                 
01408                     }
01409               }
01410           }    
01411       
01412 
01413         if (ret == 0)  /* Valeurs sur les faces */
01414           {
01415             for (k=0;k<MED_NBR_GEOMETRIE_FACE;k++)
01416               {
01417                 typgeo = typfac[k];
01418 
01419                 /* Combien de pas de temps ? */
01420                 npdt = MEDnPasdetemps(fid,nomcha,MED_FACE,typgeo);
01421                 if (npdt < 0)
01422                   ret = -1;
01423                 if (ret == -1)
01424                   strcpy(message,">> ERREUR : la lecture du nombe de pas de temps");
01425                 else
01426                   fprintf(stdout,"\n  - Il y a %d pas de temps sur les faces de type %d \n",npdt,typgeo);
01427 
01428                 /* Lecture des valeurs pour tous les pas de temps */
01429                 if (ret == 0)
01430                   for (j=0;j<npdt;j++)
01431                     {
01432                       /* Informations sur les pas de temps */
01433                       if (ret == 0)
01434                         ret = MEDpasdetempsInfo(fid,nomcha,MED_FACE,typgeo,
01435                                                 j+1, maillage_champ, &ngauss, &numdt,  dtunit, &dt, &numo);
01436 
01437                       if (ret == 0 && (! strcmp(maillage_champ,nommaa)))
01438                         fprintf(stdout,"\n  -> \tPas de Temps n° %4i (%f), N°d'ordre %4i, avec %i pts de gauss\n",
01439                                 numdt,dt,numo,ngauss);
01440                       else
01441                         strcpy(message,">> ERREUR : information sur les pas de temps \n");
01442 
01443                       /* Combien de valeurs a lire ? */
01444                       if (ret == 0 && (! strcmp(maillage_champ,nommaa)))
01445                         {
01446                           if ((nval = MEDnVal(fid,nomcha,MED_FACE,typgeo,numdt,numo)) < 0)
01447                             {
01448                               ret = -1;
01449                               strcpy(message,">> ERREUR : nombre de valeurs d'un champ\n");
01450                             }
01451                           else
01452                             fprintf(stdout,"\n  - Il y a %d valeurs sur les noeuds \n",nval);
01453                         }
01454 
01455                       if (ret == 0 && (! strcmp(maillage_champ,nommaa)))
01456                         {
01457                           if (typcha == MED_REEL64)
01458                             {
01459                               valr = (med_float*) malloc(sizeof(med_float)*ncomp*nval);
01460                               ret = MEDchampLire(fid,nommaa,nomcha,(unsigned char*)valr,mode_coo,MED_ALL,
01461                                                  pflnom,MED_FACE,typgeo,numdt,numo);
01462                               if (ret < 0)
01463                                 strcpy(message,">> ERREUR : lecture des champs \n");
01464                               else
01465                                 for (kp=0;kp<nval*ncomp;kp++)
01466                                   fprintf(stdout," %f ",*(valr+kp));
01467                               free(valr);
01468                             }
01469                           else
01470                             {
01471                               vale = (med_int*) malloc(sizeof(med_int)*ncomp*nval);
01472                               ret = MEDchampLire(fid,nommaa,nomcha,(unsigned char*)vale,mode_coo,MED_ALL,
01473                                                  pflnom,MED_FACE,typgeo,numdt,numo);
01474                               if (ret < 0)
01475                                 strcpy(message,">> ERREUR : lecture des champs \n");
01476                               else
01477                                 for (kp=0;kp<nval*ncomp;kp++)
01478                                   fprintf(stdout," %d ",*(vale+kp));
01479                               free(vale);
01480                             }
01481                           
01482                           /* Lecture d'un profil eventuel */
01483                           if (strcmp(pflnom,MED_NOPFL) == 0 )
01484                             fprintf(stdout,"\n \t- Pas de profil\n");
01485                           else 
01486                             {
01487                               if ( (pflsize = MEDnValProfil(fid,pflnom)) <0)
01488                                 {
01489                                   ret = -1;
01490                                   strcpy(message,">> ERREUR : lecture de la taille du profil \n");
01491                                 }
01492                               else 
01493                                 {
01494                                   fprintf(stdout,"\n \t- Profil : %s de taille %i\n",pflnom,pflsize);
01495                                   pflval = (med_int*) malloc(sizeof(med_int)*pflsize);
01496                                   
01497                                   if ( (ret = MEDprofilLire(fid,pflval,pflnom)) <0)
01498                                     strcpy(message,">> ERREUR : lecture du profil \n");
01499                                   else
01500                                     for (l=0;l<pflsize;l++)
01501                                       fprintf(stdout,"\t%i\n",*(pflval+l));
01502                                   
01503                                   free(pflval);
01504                                 }
01505                             }
01506                         }                                 
01507                     }
01508               }
01509           }    
01510 
01511 
01512         if (ret == 0)  /* Valeurs sur les aretes */
01513           {
01514             for (k=0;k<MED_NBR_GEOMETRIE_ARETE;k++)
01515               {
01516                 typgeo = typare[k];
01517 
01518                 /* Combien de pas de temps ? */
01519                 npdt = MEDnPasdetemps(fid,nomcha,MED_ARETE,typgeo);
01520                 if (npdt < 0)
01521                   ret = -1;
01522                 if (ret == -1)
01523                   strcpy(message,">> ERREUR : la lecture du nombe de pas de temps");
01524                 else
01525                   fprintf(stdout,"\n  - Il y a %d pas de temps sur les aretes de type %d \n",npdt,typgeo);
01526 
01527                 /* Lecture des valeurs pour tous les pas de temps */
01528                 if (ret == 0)
01529                   for (j=0;j<npdt;j++)
01530                     {
01531                       /* Informations sur les pas de temps */
01532                       if (ret == 0)
01533                         ret = MEDpasdetempsInfo(fid,nomcha,MED_ARETE,typgeo,
01534                                                 j+1, maillage_champ, &ngauss, &numdt,  dtunit, &dt, &numo);
01535 
01536                       if (ret == 0 && (! strcmp(maillage_champ,nommaa)))
01537                         fprintf(stdout,"\n  -> \tPas de Temps n° %4i (%f), N°d'ordre %4i, avec %i pts de gauss\n",
01538                                 numdt,dt,numo,ngauss);
01539                       else
01540                         strcpy(message,">> ERREUR : information sur les pas de temps \n");
01541 
01542                       /* Combien de valeurs a lire ? */
01543                       if (ret == 0 && (! strcmp(maillage_champ,nommaa)))
01544                         {
01545                           if ((nval = MEDnVal(fid,nomcha,MED_ARETE,typgeo,numdt,numo)) < 0)
01546                             {
01547                               ret = -1;
01548                               strcpy(message,">> ERREUR : nombre de valeurs d'un champ\n");
01549                             }
01550                           else
01551                             fprintf(stdout,"\n  - Il y a %d valeurs sur les noeuds \n",nval);
01552                         }
01553 
01554                       if (ret == 0 && (! strcmp(maillage_champ,nommaa)))
01555                         {
01556                           if (typcha == MED_REEL64)
01557                             {
01558                               valr = (med_float*) malloc(sizeof(med_float)*ncomp*nval);
01559                               ret = MEDchampLire(fid,nommaa,nomcha,(unsigned char*)valr,mode_coo,MED_ALL,
01560                                                  pflnom,MED_ARETE,typgeo,numdt,numo);
01561                               if (ret < 0)
01562                                 strcpy(message,">> ERREUR : lecture des champs \n");
01563                               else
01564                                 for (kp=0;kp<nval*ncomp;kp++)
01565                                   fprintf(stdout," %f ",*(valr+kp));
01566                               free(valr);
01567                             }
01568                           else
01569                             {
01570                               vale = (med_int*) malloc(sizeof(med_int)*ncomp*nval);
01571                               ret = MEDchampLire(fid,nommaa,nomcha,(unsigned char*)vale,mode_coo,MED_ALL,
01572                                                  pflnom,MED_ARETE,typgeo,numdt,numo);
01573                               if (ret < 0)
01574                                 strcpy(message,">> ERREUR : lecture des champs \n");
01575                               else
01576                                 for (kp=0;kp<nval*ncomp;kp++)
01577                                   fprintf(stdout," %d ",*(vale+kp));
01578                               free(vale);
01579                             }
01580                           
01581                           /* Lecture d'un profil eventuel */
01582                           if (strcmp(pflnom,MED_NOPFL) == 0 )
01583                             fprintf(stdout,"\n \t- Pas de profil\n");
01584                           else 
01585                             {
01586                               if ( (pflsize = MEDnValProfil(fid,pflnom)) <0)
01587                                 {
01588                                   ret = -1;
01589                                   strcpy(message,">> ERREUR : lecture de la taille du profil \n");
01590                                 }
01591                               else 
01592                                 {
01593                                   fprintf(stdout,"\n \t- Profil : %s de taille %i\n",pflnom,pflsize);
01594                                   pflval = (med_int*) malloc(sizeof(med_int)*pflsize);
01595                                   
01596                                   if ( (ret = MEDprofilLire(fid,pflval,pflnom)) <0)
01597                                     strcpy(message,">> ERREUR : lecture du profil \n");
01598                                   else
01599                                     for (l=0;l<pflsize;l++)
01600                                       fprintf(stdout,"\t%i\n",*(pflval+l));
01601                                   
01602                                   free(pflval);
01603                                 }
01604                             }
01605                         }                                 
01606                     }
01607               }
01608           }    
01609 
01610       }
01611 
01612   if (ret < 0)
01613     fprintf(stderr,"%s\n",message);
01614 
01615   /****************************************************************************
01616   *                      FERMETURE DU FICHIER                                 *
01617   ****************************************************************************/
01618   ret = MEDfermer(fid);
01619   
01620   if (ret == 0)
01621     fprintf(stdout,"\n >>>>>> FIN DU DUMP DU FICHIER %s >>>>>>\n",argv[1]);
01622   else
01623    fprintf(stderr,">> ERREUR : erreur a la fermeture du fichier %s\n",argv[1]);
01624 
01625   return 0;
01626 }