MED fichier: Fichier source de mdump2.c

MED fichier

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