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