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