MED fichier
mdump2.c
Aller à la documentation de ce fichier.
1 /* This file is part of MED.
2  *
3  * COPYRIGHT (C) 1999 - 2023 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 
89 extern const char * const MED23MESH_GET_ENTITY_TYPENAME[MED_N_ENTITY_TYPES+2];
98 
100 extern const char * const MED23FIELD_GET_ENTITY_TYPENAME[MED_N_ENTITY_TYPES+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 */
118 
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 
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,
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 
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 
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 
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,
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,
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 
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,
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,
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,
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 }
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 }
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 }
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,
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 }
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,
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,
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 
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 }
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 
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;
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 
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 
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 
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 
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 :
1970  nb_geo = MED_N_NODE_FIXED_GEO;
1972  break;
1973  case MED_CELL :
1974  case MED_NODE_ELEMENT :
1976  nb_geo = MED_N_CELL_FIXED_GEO;
1978  break;
1979  case MED_DESCENDING_FACE :
1981  nb_geo = MED_N_FACE_FIXED_GEO;
1983  break;
1984  case MED_DESCENDING_EDGE :
1986  nb_geo = MED_N_EDGE_FIXED_GEO;
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]);
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  }
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 
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)
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 }
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
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
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_ACC_RDONLY
Definition: med.h:122
MED_COMMENT_SIZE
#define MED_COMMENT_SIZE
Definition: med.h:81
MED_INDEX_FACE
Definition: med.h:153
med_grid_type
med_grid_type
Definition: med.h:139
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_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
MED23FIELD_GET_ENTITY_TYPE
med_entity_type MED23FIELD_GET_ENTITY_TYPE[MED_N_ENTITY_TYPES+2]
Definition: MED23fieldIterators.c:22
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
MED_UNSTRUCTURED_MESH
Definition: med.h:133
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
med_geometry_type
int med_geometry_type
Definition: med.h:196
typmai
const med_geometry_type *const typmai
Definition: mdump2.c:114
nomfac
const char *const * nomfac
Definition: mdump2.c:119
MED_COORDINATE_AXIS1
Definition: med.h:152
MED_SNAME_SIZE
#define MED_SNAME_SIZE
Definition: med.h:84
MED_TRUE
Definition: med.h:262
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
ISCRUTE_int
#define ISCRUTE_int(entier)
Definition: med_utils.h:314
MED_N_EDGE_GEO_FIXED_CON
#define MED_N_EDGE_GEO_FIXED_CON
Definition: med.h:250
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
MED_NO_INTERLACE
Definition: med.h:100
typfac
const med_geometry_type *const typfac
Definition: mdump2.c:115
med_idt
hid_t med_idt
Definition: med.h:333
MED_FALSE
Definition: med.h:262
MED_NO_GEOTYPE
#define MED_NO_GEOTYPE
Definition: med.h:234
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
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
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
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
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
MED_SEG2
#define MED_SEG2
Definition: med.h:202
MED23FIELD_GET_FACE_GEOMETRY_TYPE
med_geometry_type MED23FIELD_GET_FACE_GEOMETRY_TYPE[MED_N_FACE_FIXED_GEO+2]
Definition: MED23fieldIterators.c:103
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
MED23MESH_GET_NODE_GEOMETRY_TYPE
med_geometry_type MED23MESH_GET_NODE_GEOMETRY_TYPE[MED_N_NODE_FIXED_GEO+2]
Definition: MED23meshIterators.c:145
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
MED23MESH_GET_CELL_GEOMETRY_TYPENAME
const char *const MED23MESH_GET_CELL_GEOMETRY_TYPENAME[MED_N_CELL_FIXED_GEO+2]
Definition: MED23meshIterators.c:73
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_err
herr_t med_err
Definition: med.h:334
MED23FIELD_GET_EDGE_GEOMETRY_TYPENAME
const char * MED23FIELD_GET_EDGE_GEOMETRY_TYPENAME[MED_N_EDGE_FIXED_GEO+2]
Definition: MED23fieldIterators.c:137
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
MED_DESCENDING_EDGE
Definition: med.h:145
med_sorting_type
med_sorting_type
Definition: med.h:311
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
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_N_NODE_FIXED_GEO
#define MED_N_NODE_FIXED_GEO
Definition: med.h:253
med_entity_type
med_entity_type
Definition: med.h:145
MED_INDEX_NODE
Definition: med.h:153
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
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
MED23FIELD_GET_ENTITY_TYPENAME
const char *const MED23FIELD_GET_ENTITY_TYPENAME[MED_N_ENTITY_TYPES+2]
Definition: MED23fieldIterators.c:33
nommai
const char *const * nommai
Definition: mdump2.c:118
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
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
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
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
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_ENTITY_TYPE
med_entity_type MED23MESH_GET_ENTITY_TYPE[MED_N_ENTITY_TYPES+2]
Definition: MED23meshIterators.c:22
MED23MESH_GET_EDGE_GEOMETRY_TYPENAME
const char * MED23MESH_GET_EDGE_GEOMETRY_TYPENAME[MED_N_EDGE_FIXED_GEO+2]
Definition: MED23meshIterators.c:137
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
MED_FULL_INTERLACE
Definition: med.h:98
med_int
int med_int
Definition: med.h:344
MED_CURVILINEAR_GRID
Definition: med.h:141
typare
const med_geometry_type *const typare
Definition: mdump2.c:116
med_field_type
med_field_type
Definition: med.h:167
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
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
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
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
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
ISCRUTE
#define ISCRUTE(entier)
Definition: med_utils.h:313
MED_POLAR_GRID
Definition: med.h:140
med_config.h
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
med_bool
med_bool
Definition: med.h:262
MED_COORDINATE_AXIS2
Definition: med.h:152
MED23FIELD_GET_FACE_GEOMETRY_TYPENAME
const char *const MED23FIELD_GET_FACE_GEOMETRY_TYPENAME[MED_N_FACE_FIXED_GEO+2]
Definition: MED23fieldIterators.c:116
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
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
MED_HEXA8
#define MED_HEXA8
Definition: med.h:215
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
MED23FIELD_GET_NODE_GEOMETRY_TYPENAME
const char * MED23FIELD_GET_NODE_GEOMETRY_TYPENAME[MED_N_NODE_FIXED_GEO+2]
Definition: MED23fieldIterators.c:151
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
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
med_float
double med_float
Definition: med.h:338
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_COORDINATE
Definition: med.h:151
MED_IFORMAT
#define MED_IFORMAT
Definition: med_utils.h:153
MED_NO_CMODE
Definition: med.h:257
IFORMAT
#define IFORMAT
Definition: med_utils.h:145
MED_POINT1
#define MED_POINT1
Definition: med.h:200
MED_NO_DT
#define MED_NO_DT
Definition: med.h:322
lecture_nombre_famille
med_int lecture_nombre_famille(med_idt fid, const char *const nommaa)
Definition: mdump2.c:128
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
MED_NONE
#define MED_NONE
Definition: med.h:233
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
MED23MESH_GET_CELL_GEOMETRY_TYPE
med_geometry_type MED23MESH_GET_CELL_GEOMETRY_TYPE[MED_N_CELL_FIXED_GEO+2]
Definition: MED23meshIterators.c:44
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
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
MEDfileClose
MEDC_EXPORT med_err MEDfileClose(med_idt fid)
Fermeture d'un fichier MED.
Definition: MEDfileClose.c:30
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:245
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
med_misc.h
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
MED_CARTESIAN_GRID
Definition: med.h:139
MED_N_CELL_FIXED_GEO
#define MED_N_CELL_FIXED_GEO
Definition: med.h:241
structure
int structure
Definition: mdump2.c:111
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
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
SSCRUTE
#define SSCRUTE(chaine)
Definition: med_utils.h:323
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
lecture_nombre_equivalence
med_int lecture_nombre_equivalence(med_idt fid, const char *const nommaa)
Definition: mdump2.c:224
med_mesh_type
med_mesh_type
Definition: med.h:133
MED_N_ENTITY_TYPES
#define MED_N_ENTITY_TYPES
Definition: med.h:148
lecture_famille_maillage
void lecture_famille_maillage(med_idt fid, const char *const nommaa, med_int nfam)
Definition: mdump2.c:137
MED_FLOAT64
Definition: med.h:168
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)
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
MED_CELL
Definition: med.h:145
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
lecture_nombre_joint
med_int lecture_nombre_joint(med_idt fid, const char *const nommaa)
Definition: mdump2.c:400
MED_LNAME_SIZE
#define MED_LNAME_SIZE
Definition: med.h:85
MED23FIELD_GET_NODE_GEOMETRY_TYPE
med_geometry_type MED23FIELD_GET_NODE_GEOMETRY_TYPE[MED_N_NODE_FIXED_GEO+2]
Definition: MED23fieldIterators.c:145
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
MED_NAME_SIZE
#define MED_NAME_SIZE
Definition: med.h:83
xstr
#define xstr(s)
Definition: mdump2.c:125
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
med_data_type
med_data_type
Definition: med.h:151
MED_COORDINATE_AXIS3
Definition: med.h:152
MED_N_CELL_GEO_FIXED_CON
#define MED_N_CELL_GEO_FIXED_CON
Definition: med.h:242
med_switch_mode
med_switch_mode
Definition: med.h:98
MED_NODE_ELEMENT
Definition: med.h:146
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
MED_N_EDGE_FIXED_GEO
#define MED_N_EDGE_FIXED_GEO
Definition: med.h:249
MED23FIELD_GET_EDGE_GEOMETRY_TYPE
med_geometry_type MED23FIELD_GET_EDGE_GEOMETRY_TYPE[MED_N_EDGE_FIXED_GEO+2]
Definition: MED23fieldIterators.c:129
MED_ALL_CONSTITUENT
#define MED_ALL_CONSTITUENT
Definition: med.h:301
lecture_equivalence_maillage
void lecture_equivalence_maillage(med_idt fid, const char *const nommaa, med_int nequ)
Definition: mdump2.c:234
med_utils.h
MED_NODE
Definition: med.h:145
MED23MESH_GET_ENTITY_TYPENAME
const char *const MED23MESH_GET_ENTITY_TYPENAME[MED_N_ENTITY_TYPES+2]
Definition: MED23meshIterators.c:33
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
MED_N_FACE_GEO_FIXED_CON
#define MED_N_FACE_GEO_FIXED_CON
Definition: med.h:246
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
MED_NO_PROFILE
#define MED_NO_PROFILE
Definition: med.h:283
USER_MODE
#define USER_MODE
Definition: mdump2.c:123
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
EXIT_IF
#define EXIT_IF(expression, message, arg)
Definition: med_utils.h:343
med_axis_type
med_axis_type
Definition: med.h:260
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
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
MED23MESH_GET_FACE_GEOMETRY_TYPENAME
const char *const MED23MESH_GET_FACE_GEOMETRY_TYPENAME[MED_N_FACE_FIXED_GEO+2]
Definition: MED23meshIterators.c:116
med.h
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
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_CONNECTIVITY
Definition: med.h:151
MED_NO_IT
#define MED_NO_IT
Definition: med.h:323
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_DESCENDING
Definition: med.h:257
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
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
lecture_joint_maillage
void lecture_joint_maillage(med_idt fid, const char *const nommaa, med_int njnt)
Definition: mdump2.c:410
MEDfileOpen
MEDC_EXPORT med_idt MEDfileOpen(const char *const filename, const med_access_mode accessmode)
Ouverture d'un fichier MED.
Definition: MEDfileOpen.c:42
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
parametrage
void parametrage(med_switch_mode *mode_coo, med_connectivity_mode *typ_con)
Definition: mdump2.c:2535
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
MED23MESH_GET_NODE_GEOMETRY_TYPENAME
const char * MED23MESH_GET_NODE_GEOMETRY_TYPENAME[MED_N_NODE_FIXED_GEO+2]
Definition: MED23meshIterators.c:151
main
int main(int argc, char **argv)
Definition: mdump2.c:2635
MED_POLYHEDRON
#define MED_POLYHEDRON
Definition: med.h:227
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_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
str
#define str(s)
Definition: mdump2.c:126
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
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
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
MED23MESH_GET_EDGE_GEOMETRY_TYPE
med_geometry_type MED23MESH_GET_EDGE_GEOMETRY_TYPE[MED_N_EDGE_FIXED_GEO+2]
Definition: MED23meshIterators.c:129
MED_UNDEF_GRID_TYPE
Definition: med.h:142
MED_QUAD4
#define MED_QUAD4
Definition: med.h:206
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
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_NODAL
Definition: med.h:257
_MEDgetExternalGeometryTypeName
MEDC_EXPORT med_err _MEDgetExternalGeometryTypeName(char *const geotypename, med_geometry_type geotype)
MED_POLYGON
#define MED_POLYGON
Definition: med.h:225
lecture_parametres_scalaires
void lecture_parametres_scalaires(med_idt fid, int lecture_en_tete_seulement)
Definition: mdump2.c:2402
med_connectivity_mode
med_connectivity_mode
Definition: med.h:257
MED_DESCENDING_FACE
Definition: med.h:145
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