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