1 /******************************************************************************
2 * - Nom du fichier : mdump.c
4 * - Description : utilitaire de dump pour fichier MED V2.1
6 *****************************************************************************/
7 #define NBR_MAILLE_EQU 7
14 using namespace med_2_1;
16 /*******************************************************************
17 * DUMP D'UN FICHIER MED STRUCTURE EN GRILLE : *
18 * NOEUDS, ELEMENTS, FAMILLES, EQUIVALENCES, CHAMPS DE RESULTATS *
19 *******************************************************************/
21 int grid_cartesian_or_polar(med_idt fid, int numero, med_mode_switch mode_coo) {
22 med_int mdim, nnoe, nfam, i, j;
23 char nommaa[MED_TAILLE_NOM+1];
24 char nom_universel[MED_TAILLE_LNOM+1];
27 char nomcoo[3*MED_TAILLE_PNOM+1];
28 char unicoo[3*MED_TAILLE_PNOM+1];
30 char str[MED_TAILLE_PNOM+1];
32 fprintf(stdout,"\n(****************************)\n");
33 fprintf(stdout,"(* INFORMATIONS GENERALES : *)\n");
34 fprintf(stdout,"(****************************)\n");
36 /* lecture du nom et de la dimension de la grille */
37 if (MEDmaaInfo(fid, numero, nommaa, &mdim) < 0) {
38 fprintf(stderr, ">> ERREUR : lecture du nom de la grille\n");
41 fprintf(stdout, "- Nom de la grille : <<%s>>\n", nommaa);
42 fprintf(stdout, "- Dimension de la grille : %d\n", mdim);
44 /* lecture du nom universel (presence optionnelle) */
45 if (MEDunvLire(fid, nommaa, nom_universel) > 0) {
46 fprintf(stdout, "- Nom universel de la grille : %s \n", nom_universel);
48 fprintf(stdout, "- Pas de nom universel \n");
51 /* nombre de familles */
52 nfam = MEDnFam(fid, nommaa, 0, (med_dim_famille)0);
54 fprintf(stderr, ">> ERREUR : lecture du nombre de familles\n");
57 fprintf(stdout, "- Nombre de familles : %d \n", nfam);
59 fprintf(stdout, "\n- Lecture des indices : \n");
60 for (i=0; i<mdim; i++) {
61 fprintf(stdout, "-- Lecture de l'indice : %d\n", i);
62 nnoe = MEDnGrid(fid, nommaa, (med_grid)i);
63 fprintf(stdout, "-- nombre d'indice : %d\n", nnoe);
64 coo = (med_float*)malloc(sizeof(med_float)*nnoe);
66 if (MEDgridLire(fid, nommaa, mdim, coo, i, mode_coo, &rep, nomcoo, unicoo) < 0) {
67 fprintf(stderr, ">> ERREUR : lecture des indices \n");
71 fprintf(stdout, "- Type de repere des coordonnees : %d \n", rep);
73 fprintf(stdout, "- Nom des coordonnees : \n");
74 for (j=0; j<mdim; j++) {
75 strncpy(str, nomcoo+j*MED_TAILLE_PNOM, MED_TAILLE_PNOM);
76 str[MED_TAILLE_PNOM] = '\0';
77 fprintf(stdout, " %s ", str);
80 fprintf(stdout, "\n- Unites des coordonnees : \n");
81 for (j=0; j<mdim; j++) {
82 strncpy(str, unicoo+j*MED_TAILLE_PNOM, MED_TAILLE_PNOM);
83 str[MED_TAILLE_PNOM] = '\0';
84 fprintf(stdout, " %s ", str);
87 fprintf(stdout, "\n-- Coordonnees des indices : \n");
88 for (j=0; j<nnoe; j++) {
89 fprintf(stdout, " %f ", *(coo+j));
92 fprintf(stdout, "\n\n");
96 nfam = MEDnGrid(fid, nommaa, (med_grid)-2);
97 fprintf(stdout, "- Nombre de noeud pour les familles : %d\n", nfam);
99 fam = (med_int*)malloc(sizeof(med_int)*nfam);
100 if (MEDfamGridLire(fid, nommaa, fam, nfam,MED_NOEUD) < 0) {
101 fprintf(stderr, ">> ERREUR : lecture des familles\n");
102 return(EXIT_FAILURE);
105 fprintf(stdout, "\n- Numeros des familles des noeuds :\n");
106 for (i=0; i<nfam; i++) {
107 fprintf(stdout, " %d ", *(fam+i));
109 fprintf(stdout, "\n");
116 int grid_body_fitted(med_idt fid, int numero, med_mode_switch mode_coo) {
117 med_int mdim, nnoe, nfam, i;
118 char nommaa[MED_TAILLE_NOM+1];
119 char nom_universel[MED_TAILLE_LNOM+1];
120 char str[MED_TAILLE_PNOM+1];
121 char nomcoo[3*MED_TAILLE_PNOM+1];
122 char unicoo[3*MED_TAILLE_PNOM+1];
127 fprintf(stdout,"\n(****************************)\n");
128 fprintf(stdout,"(* INFORMATIONS GENERALES : *)\n");
129 fprintf(stdout,"(****************************)\n");
131 /* lecture du nom et de la dimension du maillage */
132 if (MEDmaaInfo(fid, numero, nommaa, &mdim) < 0) {
133 fprintf(stderr, ">> ERREUR : lecture du nom du maillage body fitted\n");
134 return(EXIT_FAILURE);
136 fprintf(stdout, "- Nom du maillage body fitted : <<%s>>\n", nommaa);
137 fprintf(stdout, "- Dimension du maillage body fitted : %d\n", mdim);
139 /* lecture du nom universel (presence optionnelle) */
140 if (MEDunvLire(fid, nommaa, nom_universel) > 0) {
141 fprintf(stdout, "- Nom universel du maillage body fitted : %s \n", nom_universel);
143 fprintf(stdout, "- Pas de nom universel \n");
146 /* Combien de noeuds ? */
147 /* nnoe = MEDnGrid(fid, nommaa, -1);*/
148 nnoe = MEDnGrid(fid, nommaa, MED_GRID_NOEUD);
150 fprintf(stderr, ">> ERREUR : lecture du nombre de noeuds (via MEDnGrid) \n");
151 return(EXIT_FAILURE);
153 fprintf(stdout, "- Nombre de noeuds : %d \n", nnoe);
155 /* Combien de noeuds dans la dimension 1 ? */
156 i = MEDnGrid(fid, nommaa, (med_grid)0);
158 fprintf(stderr, ">> ERREUR : lecture du nombre de noeuds (via MEDnGrid) dans la dimension 1 \n");
159 return(EXIT_FAILURE);
161 fprintf(stdout, "- Nombre de noeuds dans la dimension 1 : %d \n", i);
163 /* Combien de noeuds dans la dimension 2 ? */
164 i = MEDnGrid(fid, nommaa, (med_grid)1);
166 fprintf(stderr, ">> ERREUR : lecture du nombre de noeuds (via MEDnGrid) dans la dimension 2 \n");
167 return(EXIT_FAILURE);
169 fprintf(stdout, "- Nombre de noeuds dans la dimension 2 : %d \n", i);
171 /* nombre de familles */
172 nfam = MEDnFam(fid, nommaa, 0,(med_dim_famille)0);
174 fprintf(stderr, ">> ERREUR : lecture du nombre de familles \n");
175 return(EXIT_FAILURE);
177 fprintf(stdout, "- Nombre de familles : %d \n", nfam);
179 coo = (med_float*)malloc(sizeof(med_float)*nnoe*mdim);
180 fam = (med_int*)malloc(sizeof(med_int)*nnoe);
182 if (MEDbodyFittedLire(fid, nommaa, mdim, coo, mode_coo, &rep, nomcoo, unicoo, fam, nnoe) < 0) {
183 fprintf(stderr, ">> ERREUR : lecture des noeuds \n");
184 return(EXIT_FAILURE);
187 fprintf(stdout, "- Type de repere des coordonnees : %d \n", rep);
189 fprintf(stdout, "- Nom des coordonnees : \n");
190 for (i=0; i<mdim; i++) {
191 strncpy(str, nomcoo+i*MED_TAILLE_PNOM, MED_TAILLE_PNOM);
192 str[MED_TAILLE_PNOM] = '\0';
193 fprintf(stdout, " %s ", str);
196 fprintf(stdout, "\n- Unites des coordonnees : \n");
197 for (i=0; i<mdim; i++) {
198 strncpy(str, unicoo+i*MED_TAILLE_PNOM, MED_TAILLE_PNOM);
199 str[MED_TAILLE_PNOM] = '\0';
200 fprintf(stdout, " %s ", str);
203 fprintf(stdout, "\n- Coordonnees des noeuds : \n");
204 for (i=0; i<nnoe*mdim; i++) {
205 fprintf(stdout, " %f ", *(coo+i));
208 fprintf(stdout, "\n- Numeros des familles des noeuds : \n");
209 for (i=0; i<nnoe; i++) {
210 fprintf(stdout, " %d ", *(fam+i));
212 fprintf(stdout, "\n");
221 int grid(med_idt fid, int numero, med_grid_type theType, med_mode_switch mode_coo) {
223 case MED_CARTESIAN : {
224 fprintf(stdout, "- Type de la grille : MED_CARTESIAN\n");
225 return(grid_cartesian_or_polar(fid, numero, mode_coo));
228 fprintf(stdout, "- Type de la grille : MED_POLAR\n");
229 return(grid_cartesian_or_polar(fid, numero, mode_coo));
231 case MED_BODY_FITTED : {
232 fprintf(stdout, "- Type de la grille : MED_BODY_FITTED\n");
233 return(grid_body_fitted(fid, numero, mode_coo));
236 fprintf(stderr, ">> ERREUR : type de maillage inconnu\n");
237 return(EXIT_FAILURE);
242 /******************************************************************************
243 * DUMP D'UN FICHIER MED : NOEUDS,
244 * ELEMENTS, FAMILLES, EQUIVALENCES, CHAMPS DE RESULTATS
245 *****************************************************************************/
247 int main (int argc, char **argv)
254 /* nombre d'objets MED */
255 char nom_universel[MED_TAILLE_LNOM+1];
256 med_int long_fichier_en_tete;
257 char *fichier_en_tete;
258 char version_hdf[10];
259 char version_med[10];
260 med_int nmaa,mdim,nnoe;
261 med_int nmai[MED_NBR_GEOMETRIE_MAILLE],nfac[MED_NBR_GEOMETRIE_FACE];
262 med_int nare[MED_NBR_GEOMETRIE_ARETE];
263 /* nom du maillage */
264 char nommaa[MED_TAILLE_NOM+1];
267 char nomcoo[3*MED_TAILLE_PNOM+1];
268 char unicoo[3*MED_TAILLE_PNOM+1];
273 med_booleen inonoe,inunoe;
274 med_mode_switch mode_coo;
275 char str[MED_TAILLE_PNOM+1];
280 med_int *connectivite;
284 med_booleen inoele, inuele;
285 med_connectivite typ_con;
286 med_geometrie_element typgeo;
287 med_geometrie_element typmai[MED_NBR_GEOMETRIE_MAILLE] = {MED_POINT1,MED_SEG2,
290 MED_QUAD8,MED_TETRA4,
291 MED_TETRA10,MED_HEXA8,
292 MED_HEXA20,MED_PENTA6,
293 MED_PENTA15,MED_PYRA5,
295 med_int desmai[MED_NBR_GEOMETRIE_MAILLE] = {0,2,3,3,3,4,4,4,4,6,6,5,5,5,5};
296 med_int nmailles[MED_NBR_GEOMETRIE_MAILLE];
297 char nommai[MED_NBR_GEOMETRIE_MAILLE] [MED_TAILLE_NOM+1] = {"MED_POINT1",
312 med_geometrie_element typfac[MED_NBR_GEOMETRIE_FACE] = {MED_TRIA3,MED_TRIA6,
313 MED_QUAD4,MED_QUAD8};
314 med_int desfac[MED_NBR_GEOMETRIE_FACE] = {3,3,4,4};
315 med_int nfaces[MED_NBR_GEOMETRIE_FACE];
316 char nomfac[MED_NBR_GEOMETRIE_FACE][MED_TAILLE_NOM+1] = {"MED_TRIA3","MED_TRIA6",
317 "MED_QUAD4","MED_QUAD8"};
318 med_geometrie_element typare[MED_NBR_GEOMETRIE_ARETE] = {MED_SEG2,MED_SEG3};
319 med_int desare[MED_NBR_GEOMETRIE_ARETE] = {2,3};
320 med_int naretes[MED_NBR_GEOMETRIE_ARETE];
321 char nomare[MED_NBR_GEOMETRIE_ARETE] [MED_TAILLE_NOM+1] = {"MED_SEG2","MED_SEG3"};
326 med_int *attval,*attide;
327 char nomfam[MED_TAILLE_NOM+1];
329 char str1[MED_TAILLE_DESC+1];
330 char str2[MED_TAILLE_LNOM+1];
334 char equ[MED_TAILLE_NOM+1];
335 char des[MED_TAILLE_DESC+1];
336 /* champs de resultats */
339 char nomcha[MED_TAILLE_NOM+1];
340 char maillage_champ[MED_TAILLE_NOM+1];
344 med_type_champ typcha;
348 int lecture_en_tete_seulement = 0;
350 med_int ngauss,numdt,numo;
352 char dtunit[MED_TAILLE_PNOM+1];
353 char pflnom[MED_TAILLE_NOM+1];
357 med_grid_type theType;
359 /****************************************************************************
360 * TEST DU NOMBRE D'ARGUMENTS *
361 * argument 1 = nom du fichier MED *
362 ****************************************************************************/
363 if (argc != 2 && argc != 5)
365 fprintf(stderr,">> ERREUR : nombre de parametres incorrects \n");
369 /****************************************************************************
370 * OUVERTURE DU FICHIER EN LECTURE *
371 ****************************************************************************/
372 fid = MEDouvrir(argv[1],MED_LECT);
375 fprintf(stderr,">> ERREUR : ouverture du fichier %s \n",argv[1]);
380 /****************************************************************************
381 * QUESTIONS PRELIMINAIRES *
382 * 1. Mode d'affichage des coordonnees (entrelace ou non) ? *
383 * 2. Connectivite des elements (nodale ou descendante) *
384 ****************************************************************************/
385 fprintf(stdout,"\n >>>>>> DUMP DU FICHIER %s >>>>>>\n",argv[1]);
387 /* en-tete du fichier (presence optionnelle) */
388 long_fichier_en_tete = MEDlFichDes(fid);
389 if (long_fichier_en_tete > 0)
391 fichier_en_tete = (char *) malloc(sizeof(char)*(long_fichier_en_tete+1));
392 ret = MEDfichEntete(fid,MED_FICH_DES,fichier_en_tete);
395 fprintf(stderr,">> ERREUR : lecture de l'en-tete du fichier \n");
398 fprintf(stdout,"- En-tete du fichier : %s \n",fichier_en_tete);
399 free(fichier_en_tete);
401 /* versions hdf et med */
402 ret = MEDfichEntete(fid,MED_HDF_VERSION,version_hdf);
405 fprintf(stderr,">> ERREUR : lecture du numero de version de HDF \n");
408 ret = MEDfichEntete(fid,MED_VERSION,version_med);
411 fprintf(stderr,">> ERREUR : lecture du numero de version de MED \n");
414 fprintf(stdout,"- Version de HDF utilisee : %s \n",version_hdf);
415 fprintf(stdout,"- Version de MED utilisee : %s \n",version_med);
419 fprintf(stdout,"(*****************)\n");
420 fprintf(stdout,"(* PARAMETRAGE : *)\n");
421 fprintf(stdout,"(*****************)\n");
422 fprintf(stdout,"- Mode d'affichage des coordonnées des noeuds ? \n");
423 fprintf(stdout," 1. Mode entrelacé : taper 1 \n");
424 fprintf(stdout," 2. Mode non entrelacé : taper 2 \n");
428 fprintf(stdout," Reponse : ");
429 scanf("%d",&reponse);
431 while (reponse != 1 && reponse != 2);
433 mode_coo = MED_FULL_INTERLACE;
435 mode_coo = MED_NO_INTERLACE;
437 fprintf(stdout,"- Connectivité des éléments ? \n");
438 fprintf(stdout," 1. Nodale : taper 1 \n");
439 fprintf(stdout," 2. Descendante : taper 2 \n");
443 fprintf(stdout," Reponse : ");
444 scanf("%d",&reponse);
446 while (reponse != 1 && reponse != 2);
454 if (! strcmp(argv[3],"NODALE"))
456 if (! strcmp(argv[3],"DESCENDANTE"))
459 if (!strcmp(argv[4],"NO_INTERLACE"))
460 mode_coo = MED_NO_INTERLACE;
461 if (!strcmp(argv[4],"FULL_INTERLACE"))
462 mode_coo = MED_FULL_INTERLACE;
463 if (! strcmp(argv[4],"LECTURE_EN_TETE_SEULEMENT"))
464 lecture_en_tete_seulement = 1;
468 /****************************************************************************
469 * QUEL MAILLAGE LIRE *
470 ****************************************************************************/
474 fprintf(stderr,">> ERREUR : lecture du nombre de maillages \n");
478 /* Quel maillage lire ? */
481 fprintf(stdout,"- Il y a %d maillages dans ce fichier \n",nmaa);
482 fprintf(stdout," Lequel voulez-vous lire (1|2|3|...|n) ?\n");
485 fprintf(stdout," Reponse : ");
488 while (numero > nmaa || numero <= 0);
492 numero = atoi(argv[2]);
493 if (numero > nmaa || numero <= 0)
495 fprintf(stderr,">> ERREUR : il y a %d maillages dans ce fichier \n",
501 /*****************************************************************************
502 * QUELLE SORTE DE MAILLAGE : GRILLE OU PAS *
503 *****************************************************************************/
505 fprintf(stdout,"\n(**************************************************)\n");
506 fprintf(stdout,"(* MAILLAGE STRUCTURE (GRILLE) OU NON STRUCTURE : *)\n");
507 fprintf(stdout,"(**************************************************)\n");
509 /* lecture de la sorte de maillage : structure ou pas */
510 ret = MEDgridInfo(fid, numero, &isGrid, &theType);
512 fprintf(stderr, ">> ERREUR : lecture de la sorte de maillage (structure ou pas)\n");
515 fprintf(stdout, "- Sorte de maillage : %s\n", isGrid? "structure (grille)": "non structure");
517 ret = grid(fid, numero, theType, mode_coo);
519 ret = MEDfermer(fid);
521 fprintf(stdout, "\n >>>>>> FIN DU DUMP DU FICHIER %s >>>>>>\n", argv[1]);
523 fprintf(stderr, ">> ERREUR : erreur a la fermeture du fichier %s\n", argv[1]);
533 /****************************************************************************
534 * NOMBRES D'OBJETS MED *
535 ****************************************************************************/
536 fprintf(stdout,"\n(****************************)\n");
537 fprintf(stdout,"(* INFORMATIONS GENERALES : *)\n");
538 fprintf(stdout,"(****************************)\n");
540 /* lecture du nom et de la dimension du maillage */
541 ret = MEDmaaInfo(fid,numero,nommaa,&mdim);
544 fprintf(stderr,">> ERREUR : lecture du nom du maillage \n");
547 fprintf(stdout,"- Nom du maillage : <<%s>>\n",nommaa);
548 fprintf(stdout,"- Dimension du maillage : %d\n",mdim);
550 /* lecture du nom universel (presence optionnelle) */
551 ret = MEDunvLire(fid,nommaa,nom_universel);
553 fprintf(stdout,"- Nom universel du maillage : %s \n",nom_universel);
555 fprintf(stdout,"- Pas de nom universel \n");
558 /* Combien de noeuds ? */
559 nnoe = MEDnEntMaa(fid,nommaa,MED_COOR,MED_NOEUD,(med_geometrie_element)0,(med_connectivite)0);
562 fprintf(stderr,">> ERREUR : lecture du nombre de noeuds (via MEDnEntMaa) \n");
565 fprintf(stdout,"- Nombre de noeuds : %d \n",nnoe);
567 /* Combien de mailles, faces ou aretes ? */
568 for (i=0;i<MED_NBR_GEOMETRIE_MAILLE;i++)
570 nmailles[i] = MEDnEntMaa(fid,nommaa,MED_CONN,MED_MAILLE,typmai[i],
574 fprintf(stderr,">> ERREUR : lecture du nombre de mailles \n");
577 fprintf (stdout,"- Nombre de mailles de type %s : %d \n",nommai[i],nmailles[i]);
580 for (i=0;i<MED_NBR_GEOMETRIE_FACE;i++)
582 nfaces[i] = MEDnEntMaa(fid,nommaa,MED_CONN,MED_FACE,typfac[i],
586 fprintf(stderr,">> ERREUR : lecture du nombre de faces \n");
589 fprintf (stdout,"- Nombre de faces de type %s : %d \n",nomfac[i],nfaces[i]);
592 for (i=0;i<MED_NBR_GEOMETRIE_ARETE;i++)
594 naretes[i] = MEDnEntMaa(fid,nommaa,MED_CONN,MED_ARETE,typare[i],
598 fprintf(stderr,">> ERREUR : lecture du nombre d'aretes \n");
601 fprintf (stdout,"- Nombre d'aretes de type %s : %d \n",nomare[i],naretes[i]);
604 /* nombre de familles */
605 nfam = MEDnFam(fid,nommaa,0,(med_dim_famille)0);
608 fprintf(stderr,">> ERREUR : lecture du nombre de familles \n");
611 fprintf(stdout,"- Nombre de familles : %d \n",nfam);
613 /* combien d'equivalences dans le fichier */
614 nequ = MEDnEquiv(fid,nommaa);
617 fprintf(stderr,">> ERREUR : lecture du nombre d'equivalences \n");
620 fprintf(stdout,"- Nombre d'equivalences : %d \n",nequ);
622 /* combien de champs dans le fichier */
623 ncha = MEDnChamp(fid,0);
626 fprintf(stderr,">> ERREUR : lecture du nombre de champs \n");
629 fprintf(stdout,"- Nombre de champs : %d \n",ncha);
631 /* Doit-on s'arreter ? */
632 if (lecture_en_tete_seulement)
634 ret = MEDfermer(fid);
637 fprintf(stdout,"\n >>>>>> FIN DU DUMP DU FICHIER %s >>>>>>\n",argv[1]);
642 fprintf(stderr,">> ERREUR : fermeture du fichier %s \n",argv[1]);
647 /****************************************************************************
648 * LECTURE DES NOEUDS *
649 ****************************************************************************/
650 fprintf(stdout,"\n(************************)\n");
651 fprintf(stdout,"(* NOEUDS DU MAILLAGE : *)\n");
652 fprintf(stdout,"(************************)\n");
654 /* Allocations memoires */
655 /* table des coordonnees
656 profil : (dimension * nombre de noeuds ) */
657 coo = (med_float*) malloc(sizeof(med_float)*nnoe*mdim);
658 /* table des numeros, des numeros de familles des noeuds
659 profil : (nombre de noeuds) */
660 numnoe = (med_int*) malloc(sizeof(med_int)*nnoe);
661 nufano = (med_int*) malloc(sizeof(med_int)*nnoe);
662 /* table des noms des noeuds
663 profil : (nnoe*MED_TAILLE_PNOM+1) */
664 nomnoe = (char*) malloc(MED_TAILLE_PNOM*nnoe+1);
666 /* lecture des noeuds :
668 - noms (optionnel dans un fichier MED)
669 - numeros (optionnel dans un fichier MED)
670 - numeros des familles */
671 ret = MEDnoeudsLire(fid,nommaa,mdim,coo,mode_coo,&rep,
672 nomcoo,unicoo,nomnoe,&inonoe,numnoe,&inunoe,
675 strcpy(message,">> ERREUR : lecture des noeuds \n");
677 /* affichage des resultats */
680 fprintf(stdout,"- Type de repere des coordonnees : %d \n",rep);
681 fprintf(stdout,"- Nom des coordonnees : \n");
684 strncpy(str,nomcoo+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
685 str[MED_TAILLE_PNOM] = '\0';
686 fprintf(stdout," %s ",str);
688 fprintf(stdout,"\n- Unites des coordonnees : \n");
691 strncpy(str,unicoo+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
692 str[MED_TAILLE_PNOM] = '\0';
693 fprintf(stdout," %s ",str);
695 fprintf(stdout,"\n- Coordonnees des noeuds : \n");
696 for (i=0;i<nnoe*mdim;i++)
697 fprintf(stdout," %f ",*(coo+i));
700 fprintf(stdout,"\n- Noms des noeuds : \n");
703 strncpy(str,nomnoe+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
704 str[MED_TAILLE_PNOM] = '\0';
705 fprintf(stdout," %s ",str);
710 fprintf(stdout,"\n- Numeros des noeuds : \n");
712 fprintf(stdout," %d ",*(numnoe+i));
714 fprintf(stdout,"\n- Numeros des familles des noeuds : \n");
716 fprintf(stdout," %d ",*(nufano+i));
717 fprintf(stdout,"\n");
720 /* liberation memoire */
726 /****************************************************************************
727 * LECTURE DES ELEMENTS *
728 ****************************************************************************/
729 fprintf(stdout,"\n(**************************)\n");
730 fprintf(stdout,"(* ELEMENTS DU MAILLAGE : *)\n");
731 fprintf(stdout,"(**************************)");
732 /* Lecture des connectivites, noms, numeros des mailles */
734 for (i=0;i<MED_NBR_GEOMETRIE_MAILLE;i++)
736 if (nmailles[i] > 0 && ret == 0)
738 /* dimension de la maille */
739 edim = typmai[i] / 100;
741 if (mdim == 2 || mdim == 3)
750 taille = nsup+typmai[i]%100;
754 taille = nsup+desmai[i];
761 /* allocation memoire */
762 connectivite = (med_int*)malloc(sizeof(med_int)*
764 nomele = (char*)malloc(sizeof(char)*MED_TAILLE_PNOM*
766 numele = (med_int*)malloc(sizeof(med_int)*
768 nufael = (med_int*)malloc(sizeof(med_int)*
771 /* lecture des données */
772 ret = MEDelementsLire(fid,nommaa,mdim,connectivite,mode_coo,
773 nomele,&inoele,numele,&inuele,nufael,
774 nmailles[i],MED_MAILLE,typmai[i],
777 strcpy(message,">> ERREUR : lecture des mailles \n");
779 /* affichage des resultats */
782 fprintf(stdout,"\n\n- Mailles de type %s : ", nommai[i]);
783 fprintf(stdout,"\n - Connectivité : \n");
784 for (j=0;j<nmailles[i]*taille;j++)
785 fprintf(stdout," %d ",*(connectivite+j));
788 fprintf(stdout,"\n - Noms : \n");
789 for (j=0;j<nmailles[i];j++)
791 fprintf(stdout," %d ",*(connectivite+j));
792 strncpy(str,nomele+j*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
793 str[MED_TAILLE_PNOM] = '\0';
794 fprintf(stdout," %s ",str);
799 fprintf(stdout,"\n - Numeros :\n");
800 for (j=0;j<nmailles[i];j++)
801 fprintf(stdout," %d ",*(numele+j));
803 fprintf(stdout,"\n - Numéros de familles : \n");
804 for (j=0;j<nmailles[i];j++)
805 fprintf(stdout," %d ",*(nufael+j));
808 /* liberation memoire */
817 for (i=0;i<MED_NBR_GEOMETRIE_FACE;i++)
819 if (nfaces[i] > 0 && ret == 0)
821 /* dimension de la face */
822 edim = typfac[i] / 100;
824 if (mdim == 2 || mdim == 3)
833 taille = nsup+typfac[i]%100;
837 taille = nsup+desfac[i];
844 /* allocation memoire */
845 connectivite = (med_int*)malloc(sizeof(med_int)*
847 nomele = (char*)malloc(sizeof(char)*MED_TAILLE_PNOM*
849 numele = (med_int*)malloc(sizeof(med_int)*
851 nufael = (med_int*)malloc(sizeof(med_int)*
854 /* lecture des données */
855 ret = MEDelementsLire(fid,nommaa,mdim,connectivite,mode_coo,
856 nomele,&inoele,numele,&inuele,nufael,
857 nfaces[i],MED_FACE,typfac[i],
860 strcpy(message,">> ERREUR : lecture des faces \n");
862 /* affichage des resultats */
865 fprintf(stdout,"\n- Faces de type %s : ", nomfac[i]);
866 fprintf(stdout,"\n - Connectivité : \n");
867 for (j=0;j<nfaces[i]*taille;j++)
868 fprintf(stdout," %d ",*(connectivite+j));
871 fprintf(stdout,"\n - Noms : \n");
872 for (j=0;j<nfaces[i];j++)
874 fprintf(stdout," %d ",*(connectivite+j));
875 strncpy(str,nomele+j*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
876 str[MED_TAILLE_PNOM] = '\0';
877 fprintf(stdout," %s ",str);
882 fprintf(stdout,"\n - Numeros :\n");
883 for (j=0;j<nfaces[i];j++)
884 fprintf(stdout," %d ",*(numele+j));
886 fprintf(stdout,"\n - Numéros de familles : \n");
887 for (j=0;j<nfaces[i];j++)
888 fprintf(stdout," %d ",*(nufael+j));
891 /* liberation memoire */
900 for (i=0;i<MED_NBR_GEOMETRIE_ARETE;i++)
902 if (naretes[i] > 0 && ret == 0)
904 /* dimension de l'arete */
905 edim = typare[i] / 100;
907 if (mdim == 2 || mdim == 3)
916 taille = nsup+typare[i]%100;
920 taille = nsup+desare[i];
927 /* allocation memoire */
928 connectivite = (med_int*)malloc(sizeof(med_int)*
930 nomele = (char*)malloc(sizeof(char)*MED_TAILLE_PNOM*
932 numele = (med_int*)malloc(sizeof(med_int)*
934 nufael = (med_int*)malloc(sizeof(med_int)*
937 /* lecture des données */
938 ret = MEDelementsLire(fid,nommaa,mdim,connectivite,mode_coo,
939 nomele,&inoele,numele,&inuele,nufael,
940 naretes[i],MED_ARETE,typare[i],
943 strcpy(message,">> ERREUR : lecture des aretes \n");
945 /* affichage des resultats */
948 fprintf(stdout,"\n- Aretes de type %d : ", nomare[i]);
949 fprintf(stdout,"\n - Connectivité : \n");
950 for (j=0;j<naretes[i]*taille;j++)
951 fprintf(stdout," %d ",*(connectivite+j));
954 fprintf(stdout,"\n - Noms : \n");
955 for (j=0;j<naretes[i];j++)
957 fprintf(stdout," %d ",*(connectivite+j));
958 strncpy(str,nomele+j*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
959 str[MED_TAILLE_PNOM] = '\0';
960 fprintf(stdout," %s ",str);
965 fprintf(stdout,"\n - Numeros :\n");
966 for (j=0;j<naretes[i];j++)
967 fprintf(stdout," %d ",*(numele+j));
969 fprintf(stdout,"\n - Numéros de familles : \n");
970 for (j=0;j<naretes[i];j++)
971 fprintf(stdout," %d ",*(nufael+j));
974 /* liberation memoire */
982 /****************************************************************************
983 * LECTURE DES FAMILLES *
984 ****************************************************************************/
985 printf("\n(*************************)\n");
986 printf("(* FAMILLES DU MAILLAGE : *)\n");
987 printf("(*************************)\n");
992 /* nombre de groupes */
993 ngro = MEDnFam(fid,nommaa,i+1,MED_GROUPE);
998 ">> ERREUR : lecture du nombre de groupes d'une famille \n");
1001 /* nombre d'attributs */
1004 natt = MEDnFam(fid,nommaa,i+1,MED_ATTR);
1009 ">> ERREUR : lecture du nombre d'attributs d'une famille\n");
1014 fprintf(stdout,"- Famille %d a %d attributs et %d groupes \n",i+1,natt,ngro);
1016 /* nom,numero,attributs,groupes */
1019 attide = (med_int*) malloc(sizeof(med_int)*natt);
1020 attval = (med_int*) malloc(sizeof(med_int)*natt);
1021 attdes = (char *) malloc(MED_TAILLE_DESC*natt+1);
1022 gro = (char*) malloc(MED_TAILLE_LNOM*ngro+1);
1023 ret = MEDfamInfo(fid,nommaa,i+1,nomfam,&numfam,attide,attval,
1024 attdes,&natt,gro,&ngro);
1025 fprintf(stdout," - Famille de nom %s et de numero %d : \n",nomfam,numfam);
1026 fprintf(stdout," - Attributs : \n");
1027 for (j=0;j<natt;j++)
1029 strncpy(str1,attdes+j*MED_TAILLE_DESC,MED_TAILLE_DESC);
1030 str1[MED_TAILLE_DESC] = '\0';
1031 fprintf(stdout," ide = %d - val = %d - des = %s\n",*(attide+j),
1037 fprintf(stdout," - Groupes :\n");
1038 for (j=0;j<ngro;j++)
1040 strncpy(str2,gro+j*MED_TAILLE_LNOM,MED_TAILLE_LNOM);
1041 str2[MED_TAILLE_LNOM] = '\0';
1042 fprintf(stdout," gro = %s\n",str2);
1048 /****************************************************************************
1049 * LECTURE DES EQUIVALENCES *
1050 ****************************************************************************/
1051 fprintf(stdout,"\n(******************************)\n");
1052 fprintf(stdout,"(* EQUIVALENCES DU MAILLAGE : *)\n");
1053 fprintf(stdout,"(******************************)\n");
1055 /* lecture de toutes les equivalences associes a nommaa */
1057 for (i = 0;i<nequ;i++)
1059 fprintf(stdout,"- Equivalence numero : %d ",i+1);
1061 /* lecture des infos sur l'equivalence */
1062 ret = MEDequivInfo(fid,nommaa,i+1,equ,des);
1065 fprintf(stdout,"\n - Nom de l'equivalence: %s \n",equ);
1066 fprintf(stdout,"\n - Description de l'equivalence : %s \n",des);
1069 strcpy(message,">> ERREUR : lecture informations sur equivalence\n");
1071 /* lecture des correspondances sur les differents types d'entites */
1075 if ((ncor = MEDnCorres(fid,nommaa,equ,MED_NOEUD,(med_geometrie_element)0)) < 0)
1078 strcpy(message,">> ERREUR : lecture nombre de correspondances\n");
1081 fprintf(stdout,"\n - Il y a %d correspondances sur les noeuds \n",ncor);
1084 cor = (med_int*) malloc(sizeof(med_int)*ncor*2);
1085 ret = MEDequivLire(fid,nommaa,equ,cor,ncor,MED_NOEUD,(med_geometrie_element)0);
1087 for (j=0;j<ncor;j++)
1088 fprintf(stdout,"\n - Correspondance %d : %d et %d \n",j+1,*(cor+2*j),
1091 strcpy(message,">> ERREUR : lecture des correspondances\n");
1095 /* sur les mailles : on ne prend pas en compte les mailles 3D */
1097 for (j=0;j<NBR_MAILLE_EQU;j++)
1099 if ((ncor = MEDnCorres(fid,nommaa,equ,MED_MAILLE,typmai[j])) < 0)
1103 ">> ERREUR : lecture informations sur nombre de correspondances \n");
1106 fprintf(stdout,"\n - Il y a %d correspondances sur les mailles %s \n",ncor,
1110 cor = (med_int*) malloc(sizeof(med_int)*ncor*2);
1111 ret = MEDequivLire(fid,nommaa,equ,cor,ncor,MED_MAILLE,
1114 for (k=0;k<ncor;k++)
1115 fprintf(stdout,"\n - Correspondance %d : %d et %d \n",k+1,*(cor+2*k),
1118 strcpy(message,">> ERREUR : correspondances\n");
1125 for (j=0;j<MED_NBR_GEOMETRIE_FACE;j++)
1127 if ((ncor = MEDnCorres(fid,nommaa,equ,MED_FACE,typfac[j])) < 0)
1130 strcpy(message,">> ERREUR : informations sur correspondances \n");
1133 fprintf(stdout,"\n - Il y a %d correspondances sur les faces %s\n",ncor,
1137 cor = (med_int*) malloc(sizeof(med_int)*ncor*2);
1138 ret = MEDequivLire(fid,nommaa,equ,cor,ncor,MED_FACE,
1141 strcpy(message,"ERREUR : lecture des equivalences \n");
1143 for (k=0;k<ncor;k++)
1144 fprintf(stdout,"\n - Correspondance %d : %d et %d \n",k+1,*(cor+2*k),
1150 /* sur les aretes */
1151 for (j=0;j<MED_NBR_GEOMETRIE_ARETE;j++)
1153 if ((ncor = MEDnCorres(fid,nommaa,equ,MED_ARETE,typare[j])) < 0)
1156 strcpy(message,">> ERREUR : nombre de correspondances \n");
1159 fprintf(stdout,"\n - Il y a %d correspondances sur les aretes %s \n",
1163 cor = (med_int*) malloc(sizeof(med_int)*ncor*2);
1164 ret = MEDequivLire(fid,nommaa,equ,cor,ncor,MED_ARETE,
1167 strcpy(message,">> ERREUR : equivalences \n");
1169 for (k=0;k<ncor;k++)
1170 fprintf(stdout,"\n Correspondance %d : %d et %d \n",k+1,*(cor+2*k),
1178 /****************************************************************************
1179 * LECTURE DES CHAMPS *
1180 ****************************************************************************/
1181 fprintf(stdout,"\n(************************)\n");
1182 fprintf(stdout,"(* CHAMPS DU MAILLAGE : *)\n");
1183 fprintf(stdout,"(************************)\n");
1186 for (i=0;i<ncha;i++)
1188 fprintf(stdout,"- Champ numero : %d \n",i+1);
1190 /* combien de composantes */
1191 if ((ncomp = MEDnChamp(fid,i+1)) < 0)
1194 strcpy(message,">> ERREUR : nombre de composants d'un champ\n");
1197 /* allocation memoire de comp et unit*/
1200 comp = (char*) malloc(ncomp*MED_TAILLE_PNOM+1);
1201 unit = (char*) malloc(ncomp*MED_TAILLE_PNOM+1);
1204 /* infos sur les champs */
1206 ret = MEDchampInfo(fid,i+1,nomcha,&typcha,comp,unit,ncomp);
1208 strcpy(message,">> ERREUR : information sur les champs \n");
1211 fprintf(stdout," - Nom du champ : %s de type %d\n",nomcha,typcha);
1212 fprintf(stdout," - Nom des composantes : %s\n",comp);
1213 fprintf(stdout," - Unites des composantes : %s \n",unit);
1219 if (ret == 0) /* Valeurs sur les noeuds */
1221 /* Combien de pas de temps ? */
1222 npdt = MEDnPasdetemps(fid,nomcha,MED_NOEUD,(med_geometrie_element)0);
1226 strcpy(message,">> ERREUR : la lecture du nombe de pas de temps");
1228 fprintf(stdout,"\n - Il y a %d pas de temps sur les noeuds \n",npdt);
1230 /* Lecture des valeurs pour tous les pas de temps */
1232 for (j=0;j<npdt;j++)
1234 /* Informations sur les pas de temps */
1236 ret = MEDpasdetempsInfo(fid,nomcha,MED_NOEUD,(med_geometrie_element)0,
1237 j+1, maillage_champ, &ngauss, &numdt, dtunit, &dt, &numo);
1239 if (ret == 0 && (! strcmp(maillage_champ,nommaa)))
1240 fprintf(stdout,"\n -> \tPas de Temps n° %4i (%f), N°d'ordre %4i, avec %i pts de gauss\n",
1241 numdt,dt,numo,ngauss);
1243 strcpy(message,">> ERREUR : information sur les pas de temps \n");
1245 /* Combien de valeurs a lire ? */
1246 if (ret == 0 && (! strcmp(maillage_champ,nommaa)))
1248 if ((nval = MEDnVal(fid,nomcha,MED_NOEUD,(med_geometrie_element)0,numdt,numo)) < 0)
1251 strcpy(message,">> ERREUR : nombre de valeurs d'un champ\n");
1254 fprintf(stdout,"\n - Il y a %d valeurs sur les noeuds \n",nval);
1257 if (ret == 0 && (! strcmp(maillage_champ,nommaa)))
1259 if (typcha == MED_REEL64)
1261 valr = (med_float*) malloc(sizeof(med_float)*ncomp*nval);
1262 ret = MEDchampLire(fid,nommaa,nomcha,(unsigned char*)valr,mode_coo,MED_ALL,
1263 pflnom,MED_NOEUD,(med_geometrie_element)0,numdt,numo);
1266 strcpy(message,">> ERREUR : lecture des champs \n");
1268 for (k=0;k<nval*ncomp;k++)
1269 fprintf(stdout," %f ",*(valr+k));
1274 vale = (med_int*) malloc(sizeof(med_int)*ncomp*nval);
1275 ret = MEDchampLire(fid,nommaa,nomcha,(unsigned char*)vale,mode_coo,MED_ALL,
1276 pflnom,MED_NOEUD,(med_geometrie_element)0,numdt,numo);
1278 strcpy(message,">> ERREUR : lecture des champs \n");
1280 for (k=0;k<nval*ncomp;k++)
1281 fprintf(stdout," %d ",*(vale+k));
1285 /* Lecture d'un profil eventuel */
1286 if (strcmp(pflnom,MED_NOPFL) == 0 )
1287 fprintf(stdout,"\n \t- Pas de profil\n");
1290 if ( (pflsize = MEDnValProfil(fid,pflnom)) <0)
1293 strcpy(message,">> ERREUR : lecture de la taille du profil \n");
1297 fprintf(stdout,"\n \t- Profil : %s de taille %i\n",pflnom,pflsize);
1298 pflval = (med_int*) malloc(sizeof(med_int)*pflsize);
1300 if ( (ret = MEDprofilLire(fid,pflval,pflnom)) <0)
1301 strcpy(message,">> ERREUR : lecture du profil \n");
1303 for (l=0;l<pflsize;l++)
1304 fprintf(stdout,"\t%i\n",*(pflval+l));
1314 if (ret == 0) /* Valeurs sur les mailles */
1316 for (k=0;k<MED_NBR_GEOMETRIE_MAILLE;k++)
1320 /* Combien de pas de temps ? */
1321 npdt = MEDnPasdetemps(fid,nomcha,MED_MAILLE,typgeo);
1325 strcpy(message,">> ERREUR : la lecture du nombe de pas de temps");
1327 fprintf(stdout,"\n - Il y a %d pas de temps sur les mailles de type %d \n",npdt,typgeo);
1329 /* Lecture des valeurs pour tous les pas de temps */
1331 for (j=0;j<npdt;j++)
1333 /* Informations sur les pas de temps */
1335 ret = MEDpasdetempsInfo(fid,nomcha,MED_MAILLE,typgeo,
1336 j+1, maillage_champ, &ngauss, &numdt, dtunit, &dt, &numo);
1338 if (ret == 0 && (! strcmp(maillage_champ,nommaa)))
1339 fprintf(stdout,"\n -> \tPas de Temps n° %4i (%f), N°d'ordre %4i, avec %i pts de gauss\n",
1340 numdt,dt,numo,ngauss);
1342 strcpy(message,">> ERREUR : information sur les pas de temps \n");
1344 /* Combien de valeurs a lire ? */
1345 if (ret == 0 && (! strcmp(maillage_champ,nommaa)))
1347 if ((nval = MEDnVal(fid,nomcha,MED_MAILLE,typgeo,numdt,numo)) < 0)
1350 strcpy(message,">> ERREUR : nombre de valeurs d'un champ\n");
1353 fprintf(stdout,"\n - Il y a %d valeurs sur les noeuds \n",nval);
1356 if (ret == 0 && (! strcmp(maillage_champ,nommaa)))
1358 if (typcha == MED_REEL64)
1360 valr = (med_float*) malloc(sizeof(med_float)*ncomp*nval);
1361 ret = MEDchampLire(fid,nommaa,nomcha,(unsigned char*)valr,mode_coo,MED_ALL,
1362 pflnom,MED_MAILLE,typgeo,numdt,numo);
1364 strcpy(message,">> ERREUR : lecture des champs \n");
1366 for (kp=0;kp<nval*ncomp;kp++)
1367 fprintf(stdout," %f ",*(valr+kp));
1372 vale = (med_int*) malloc(sizeof(med_int)*ncomp*nval);
1373 ret = MEDchampLire(fid,nommaa,nomcha,(unsigned char*)vale,mode_coo,MED_ALL,
1374 pflnom,MED_MAILLE,typgeo,numdt,numo);
1376 strcpy(message,">> ERREUR : lecture des champs \n");
1378 for (kp=0;kp<nval*ncomp;kp++)
1379 fprintf(stdout," %d ",*(vale+kp));
1383 /* Lecture d'un profil eventuel */
1384 if (strcmp(pflnom,MED_NOPFL) == 0 )
1385 fprintf(stdout,"\n \t- Pas de profil\n");
1388 if ( (pflsize = MEDnValProfil(fid,pflnom)) <0)
1391 strcpy(message,">> ERREUR : lecture de la taille du profil \n");
1395 fprintf(stdout,"\n \t- Profil : %s de taille %i\n",pflnom,pflsize);
1396 pflval = (med_int*) malloc(sizeof(med_int)*pflsize);
1398 if ( (ret = MEDprofilLire(fid,pflval,pflnom)) <0)
1399 strcpy(message,">> ERREUR : lecture du profil \n");
1401 for (l=0;l<pflsize;l++)
1402 fprintf(stdout,"\t%i\n",*(pflval+l));
1413 if (ret == 0) /* Valeurs sur les faces */
1415 for (k=0;k<MED_NBR_GEOMETRIE_FACE;k++)
1419 /* Combien de pas de temps ? */
1420 npdt = MEDnPasdetemps(fid,nomcha,MED_FACE,typgeo);
1424 strcpy(message,">> ERREUR : la lecture du nombe de pas de temps");
1426 fprintf(stdout,"\n - Il y a %d pas de temps sur les faces de type %d \n",npdt,typgeo);
1428 /* Lecture des valeurs pour tous les pas de temps */
1430 for (j=0;j<npdt;j++)
1432 /* Informations sur les pas de temps */
1434 ret = MEDpasdetempsInfo(fid,nomcha,MED_FACE,typgeo,
1435 j+1, maillage_champ, &ngauss, &numdt, dtunit, &dt, &numo);
1437 if (ret == 0 && (! strcmp(maillage_champ,nommaa)))
1438 fprintf(stdout,"\n -> \tPas de Temps n° %4i (%f), N°d'ordre %4i, avec %i pts de gauss\n",
1439 numdt,dt,numo,ngauss);
1441 strcpy(message,">> ERREUR : information sur les pas de temps \n");
1443 /* Combien de valeurs a lire ? */
1444 if (ret == 0 && (! strcmp(maillage_champ,nommaa)))
1446 if ((nval = MEDnVal(fid,nomcha,MED_FACE,typgeo,numdt,numo)) < 0)
1449 strcpy(message,">> ERREUR : nombre de valeurs d'un champ\n");
1452 fprintf(stdout,"\n - Il y a %d valeurs sur les noeuds \n",nval);
1455 if (ret == 0 && (! strcmp(maillage_champ,nommaa)))
1457 if (typcha == MED_REEL64)
1459 valr = (med_float*) malloc(sizeof(med_float)*ncomp*nval);
1460 ret = MEDchampLire(fid,nommaa,nomcha,(unsigned char*)valr,mode_coo,MED_ALL,
1461 pflnom,MED_FACE,typgeo,numdt,numo);
1463 strcpy(message,">> ERREUR : lecture des champs \n");
1465 for (kp=0;kp<nval*ncomp;kp++)
1466 fprintf(stdout," %f ",*(valr+kp));
1471 vale = (med_int*) malloc(sizeof(med_int)*ncomp*nval);
1472 ret = MEDchampLire(fid,nommaa,nomcha,(unsigned char*)vale,mode_coo,MED_ALL,
1473 pflnom,MED_FACE,typgeo,numdt,numo);
1475 strcpy(message,">> ERREUR : lecture des champs \n");
1477 for (kp=0;kp<nval*ncomp;kp++)
1478 fprintf(stdout," %d ",*(vale+kp));
1482 /* Lecture d'un profil eventuel */
1483 if (strcmp(pflnom,MED_NOPFL) == 0 )
1484 fprintf(stdout,"\n \t- Pas de profil\n");
1487 if ( (pflsize = MEDnValProfil(fid,pflnom)) <0)
1490 strcpy(message,">> ERREUR : lecture de la taille du profil \n");
1494 fprintf(stdout,"\n \t- Profil : %s de taille %i\n",pflnom,pflsize);
1495 pflval = (med_int*) malloc(sizeof(med_int)*pflsize);
1497 if ( (ret = MEDprofilLire(fid,pflval,pflnom)) <0)
1498 strcpy(message,">> ERREUR : lecture du profil \n");
1500 for (l=0;l<pflsize;l++)
1501 fprintf(stdout,"\t%i\n",*(pflval+l));
1512 if (ret == 0) /* Valeurs sur les aretes */
1514 for (k=0;k<MED_NBR_GEOMETRIE_ARETE;k++)
1518 /* Combien de pas de temps ? */
1519 npdt = MEDnPasdetemps(fid,nomcha,MED_ARETE,typgeo);
1523 strcpy(message,">> ERREUR : la lecture du nombe de pas de temps");
1525 fprintf(stdout,"\n - Il y a %d pas de temps sur les aretes de type %d \n",npdt,typgeo);
1527 /* Lecture des valeurs pour tous les pas de temps */
1529 for (j=0;j<npdt;j++)
1531 /* Informations sur les pas de temps */
1533 ret = MEDpasdetempsInfo(fid,nomcha,MED_ARETE,typgeo,
1534 j+1, maillage_champ, &ngauss, &numdt, dtunit, &dt, &numo);
1536 if (ret == 0 && (! strcmp(maillage_champ,nommaa)))
1537 fprintf(stdout,"\n -> \tPas de Temps n° %4i (%f), N°d'ordre %4i, avec %i pts de gauss\n",
1538 numdt,dt,numo,ngauss);
1540 strcpy(message,">> ERREUR : information sur les pas de temps \n");
1542 /* Combien de valeurs a lire ? */
1543 if (ret == 0 && (! strcmp(maillage_champ,nommaa)))
1545 if ((nval = MEDnVal(fid,nomcha,MED_ARETE,typgeo,numdt,numo)) < 0)
1548 strcpy(message,">> ERREUR : nombre de valeurs d'un champ\n");
1551 fprintf(stdout,"\n - Il y a %d valeurs sur les noeuds \n",nval);
1554 if (ret == 0 && (! strcmp(maillage_champ,nommaa)))
1556 if (typcha == MED_REEL64)
1558 valr = (med_float*) malloc(sizeof(med_float)*ncomp*nval);
1559 ret = MEDchampLire(fid,nommaa,nomcha,(unsigned char*)valr,mode_coo,MED_ALL,
1560 pflnom,MED_ARETE,typgeo,numdt,numo);
1562 strcpy(message,">> ERREUR : lecture des champs \n");
1564 for (kp=0;kp<nval*ncomp;kp++)
1565 fprintf(stdout," %f ",*(valr+kp));
1570 vale = (med_int*) malloc(sizeof(med_int)*ncomp*nval);
1571 ret = MEDchampLire(fid,nommaa,nomcha,(unsigned char*)vale,mode_coo,MED_ALL,
1572 pflnom,MED_ARETE,typgeo,numdt,numo);
1574 strcpy(message,">> ERREUR : lecture des champs \n");
1576 for (kp=0;kp<nval*ncomp;kp++)
1577 fprintf(stdout," %d ",*(vale+kp));
1581 /* Lecture d'un profil eventuel */
1582 if (strcmp(pflnom,MED_NOPFL) == 0 )
1583 fprintf(stdout,"\n \t- Pas de profil\n");
1586 if ( (pflsize = MEDnValProfil(fid,pflnom)) <0)
1589 strcpy(message,">> ERREUR : lecture de la taille du profil \n");
1593 fprintf(stdout,"\n \t- Profil : %s de taille %i\n",pflnom,pflsize);
1594 pflval = (med_int*) malloc(sizeof(med_int)*pflsize);
1596 if ( (ret = MEDprofilLire(fid,pflval,pflnom)) <0)
1597 strcpy(message,">> ERREUR : lecture du profil \n");
1599 for (l=0;l<pflsize;l++)
1600 fprintf(stdout,"\t%i\n",*(pflval+l));
1613 fprintf(stderr,"%s\n",message);
1615 /****************************************************************************
1616 * FERMETURE DU FICHIER *
1617 ****************************************************************************/
1618 ret = MEDfermer(fid);
1621 fprintf(stdout,"\n >>>>>> FIN DU DUMP DU FICHIER %s >>>>>>\n",argv[1]);
1623 fprintf(stderr,">> ERREUR : erreur a la fermeture du fichier %s\n",argv[1]);