70 #include <med_config.h>
71 #include <med_utils.h>
83 #define snprintf _snprintf
114 #define MDUMP_MAX_FILE_OPEN 200
115 #define MDUMP_MAX_FILE_OPEN_INIT {INIT2X(INIT10X(INIT10X(0))) }
137 #define MED_LECTURE_MAILLAGE_SUPPORT_UNIQUEMENT 2
138 #define MED_LECTURE_ENTETE_SEULEMENT 1
140 #define USER_MODE MED_COMPACT_STMODE
142 #define xstr(s) str(s)
145 #define MIN(a,b) ((a) < (b) ? (a) : (b))
146 #define MAX(a,b) ((a) > (b) ? (a) : (b))
148 #define MAXBANNERLEN 255
153 const double *pa = (
const double *) pva;
167 const char *pa = (
const char *) pva;
185 EXIT_IF(-1,
"lors de la lecture du type d'attribut à afficher.",NULL);
196 EXIT_IF(nfam < 0,
"lors de la lecture du nombre de familles",NULL);
197 fprintf(stdout,
"- Nombre de familles : "IFORMAT" \n",nfam);
206 char *attdes=NULL,*gro=NULL;
207 med_int *attval=NULL,*attide=NULL;
216 fprintf(stdout,
"\n(**************************)\n");
217 fprintf(stdout,
"(* FAMILLES DU MAILLAGE : *)\n");
218 fprintf(stdout,
"(**************************)\n");
221 for (i=0;i<nfam;i++) {
225 EXIT_IF(ngro < 0,
"lors de la lecture du nombre de groupe d'une famille",
230 EXIT_IF(natt < 0,
"lors de la lecture du nombre d'attributs d'une famille",
240 EXIT_IF(attide == NULL,NULL,NULL);
242 EXIT_IF(attval == NULL,NULL,NULL);
244 EXIT_IF(attdes == NULL,NULL,NULL);
246 EXIT_IF(gro == NULL,NULL,NULL);
249 EXIT_IF(ret < 0,
"lors de la lecture des informations d'une famille",
256 fprintf(stdout,
" - Famille de nom %s et de numero "IFORMAT" : \n",nomfam,numfam);
257 fprintf(stdout,
" - Attributs : \n");
258 for (j=0;j<natt;j++) {
261 fprintf(stdout,
" ide = "IFORMAT" - val = "IFORMAT" - des = %s\n",*(attide+j),
267 if (attide) {free(attide);attide=NULL;}
268 if (attval) {free(attval);attval=NULL;}
269 if (attdes) {free(attdes);attdes=NULL;}
272 fprintf(stdout,
" - Groupes :\n");
273 for (j=0;j<ngro;j++) {
276 fprintf(stdout,
" gro = %s\n",str2);
281 if (gro) {free(gro);gro=NULL;}
284 if (famille_0 != 1) {
285 MESSAGE(
"Erreur : La famille FAMILLE_ZERO n'a pas été trouvée, elle est obligatoire. ");
294 EXIT_IF(nequ < 0,
"lors de la lecture du nombre d'equivalences",NULL);
295 fprintf(stdout,
"- Nombre d'equivalences : "IFORMAT" \n",nequ);
315 fprintf(stdout,
"\n(******************************)\n");
316 fprintf(stdout,
"(* EQUIVALENCES DU MAILLAGE : *)\n");
317 fprintf(stdout,
"(******************************)\n");
321 for (i = 0;i<nequ;i++) {
325 EXIT_IF(ret < 0,
"lors de la lecture des informations sur une equivalence",
329 fprintf(stdout,
"- Equivalence numero : "IFORMAT" ",i+1);
330 fprintf(stdout,
"\n - Nom de l'equivalence: %s \n",equ);
331 fprintf(stdout,
"\n - Description de l'equivalence : %s \n",des);
333 fprintf(stdout,
"\n - L'equivalence est définie sur "IFORMAT" étapes de calcul\n",nstep);
336 for (_cstpit=1; _cstpit <= nstep; ++_cstpit) {
339 & _numdt, &_numit,&nocstpncor);
341 "lors de la lecture des valeurs d'étape de calcul d'une equivalence",
345 fprintf(stdout,
"\n - Etape de calcul définie sur (numdt,numit) ("IFORMAT","IFORMAT") :\n",_numdt,_numit);
352 "lors de la lecture du nombre de correspondances d'une equivalence",
354 fprintf(stdout,
"\n - Il y a "IFORMAT" correspondances sur les noeuds \n",ncor);
360 EXIT_IF(cor == NULL,NULL,NULL);
363 EXIT_IF(ret < 0,
"lors de la lecture du tableau des correspondances",
378 "lors de la lecture du nombre de correspondances dans une equivalence",
380 fprintf(stdout,
"\n - Il y a "IFORMAT" correspondances sur les mailles %s \n",ncor,
387 EXIT_IF(cor == NULL,NULL,NULL);
390 EXIT_IF(ret < 0,
"lors de la lecture du tableau des equivalences",
396 *(cor+2*k),*(cor+2*k+1));
410 "lors de la lecture du nombre de correspondances dans une equivalence",
412 fprintf(stdout,
"\n - Il y a "IFORMAT" correspondances sur les faces %s\n",ncor,
419 EXIT_IF(cor == NULL,NULL,NULL);
422 EXIT_IF(ret < 0,
"lors de la lecture du tableau des equivalences",
440 EXIT_IF(ret < 0,
"lors de la lecture du nombre de correspondances",
442 fprintf(stdout,
"\n - Il y a "IFORMAT" correspondances sur les aretes %s \n",
449 EXIT_IF(cor == NULL,NULL,NULL);
452 EXIT_IF(ret < 0,
"lors de la lecture du tableau des equivalences",
474 EXIT_IF(njnt < 0,
"lors de la lecture du nombre de joints",NULL);
475 fprintf(stdout,
"- Nombre de joints : "IFORMAT" \n",njnt);
487 med_int typ_geo_local,typ_geo_distant;
497 med_int njstep=0,ncor=0,nodtitncor=0;
502 fprintf(stdout,
"\n(******************************)\n");
503 fprintf(stdout,
"(* JOINTS DU MAILLAGE : *)\n");
504 fprintf(stdout,
"(******************************)\n");
508 for (i = 0;i<njnt;i++) {
509 fprintf(stdout,
"- Joint numero : "IFORMAT" ",i+1);
513 EXIT_IF(ret < 0,
"lors de la lecture des informations sur un joint",
516 fprintf(stdout,
"\n - Nom du joint: %s \n",jn);
517 fprintf(stdout,
"\n - Description du joint : %s ",des);
518 fprintf(stdout,
"\n - Domaine en regard : "IFORMAT" ",ndom);
519 fprintf(stdout,
"\n - Maillage distant : %s ",maa_dist);
521 printf(
"Nombre d'étapes de calcul : "IFORMAT" \n",njstep);
522 printf(
"Nombre de correspondance pour (NO_DT,NO_IT) : "IFORMAT" \n",nodtitncor);
525 for (csit=1; csit <= njstep; ++csit) {
528 EXIT_IF(ret < 0,
"Erreur a la lecture des valeurs (numdt,numit) dans les joints",
531 printf(
"Etape de calcul (numdt,numit) : ("IFORMAT","IFORMAT")\n",_numdt,_numit);
534 while ( corit <= ncor ) {
540 EXIT_IF(ret < 0,
"Erreur a la lecture des infos sur le nombre d'entite en regard",
543 if (typ_ent_local ==
MED_NODE) strcpy(nom_geo_ent_local,
"MED_NOEUD");
545 EXIT_IF(ret < 0,
"Erreur à l'appel de _MEDgetInternalGeometryTypeName", NULL);
546 if (typ_ent_distant ==
MED_NODE) strcpy(nom_geo_ent_distant,
"MED_NOEUD");
548 EXIT_IF(ret < 0,
"Erreur à l'appel de _MEDgetInternalGeometryTypeName", NULL);
549 fprintf(stdout,
"\n\t\t- nb de couples d'entites en regard (local,distant)=(%s,%s) : "IFORMAT" \n",
550 nom_geo_ent_local,nom_geo_ent_distant, nent);
555 typ_ent_local,typ_geo_local,typ_ent_distant,typ_geo_distant,
557 fprintf(stdout,
"\n\t\t- Erreur a la lecture des correspondances sur (%s,%s,%s,%s)",
564 *(cortab+2*k),*(cortab+2*k+1));
591 EXIT_IF(nnoe < 0,
"lors de la lecture du nombre de noeuds",NULL);
592 fprintf(stdout,
"- Nombre de noeuds : "IFORMAT" \n",nnoe);
599 const char *
const nommaa,
606 const char *
const nomcoo,
607 const char *
const unicoo,
624 EXIT_IF(coo == NULL,NULL,NULL);
628 EXIT_IF(numnoe == NULL,NULL,NULL);
630 EXIT_IF(nufano == NULL,NULL,NULL);
634 EXIT_IF(nomnoe == NULL,NULL,NULL);
642 &inonoe,nomnoe,&inunoe,numnoe,&ifano,nufano);
645 EXIT_IF(ret < 0,
"lors de la lecture des noeuds du maillage \n",NULL);
649 fprintf(stdout,
"\n(************************)\n");
650 fprintf(stdout,
"(* NOEUDS DU MAILLAGE : *)\n");
651 fprintf(stdout,
"(************************)\n\n");
654 fprintf(stdout,
"- Type de repere des coordonnees : %d \n",*rep);
655 fprintf(stdout,
"- Nom des coordonnees : \n");
656 for (i=0;i<edim;i++) {
659 fprintf(stdout,
" %s ",
str);
661 fprintf(stdout,
"\n- Unites des coordonnees : \n");
662 for (i=0;i<edim;i++) {
665 fprintf(stdout,
" %s ",
str);
667 fprintf(stdout,
"\n- Coordonnees des noeuds : ");
668 for (i=0;i<nnoe*edim;i++) {
670 fprintf(stdout,
"\n [ %5"MED_IFORMAT" ] : ", (i/edim + 1) );
672 fprintf(stdout,
"\n\n ");
673 fprintf(stdout,
" %-+9.6f ",*(coo+i));
677 fprintf(stdout,
"\n- Noms des noeuds : \n");
678 for (i=0;i<nnoe;i++) {
681 fprintf(stdout,
" %s ",
str);
685 fprintf(stdout,
"\n- Numeros des noeuds : \n");
687 fprintf(stdout,
" "IFORMAT" ",*(numnoe+i));
690 fprintf(stdout,
"\n- Numeros des familles des noeuds : \n");
691 for (i=0;i<nnoe;i++) {
693 fprintf(stdout,
" "IFORMAT" ",*(nufano+i));
695 fprintf(stdout,
" %d ",0);
697 fprintf(stdout,
"\n");
712 const char *
const nommaa,
725 EXIT_IF(nmailles < 0,
" lors de la lecture du nombre de mailles",NULL);
730 fprintf (stdout,
"- Nombre de mailles de type %s : "IFORMAT" \n",
nommai[indice],
737 const char *
const nommaa,
750 indice+1,geotypename,geotype );
752 "Erreur à la demande d'informations pour le type d'entités MED_STRUCT_ELEMENT",NULL);
758 EXIT_IF(_nmailles < 0,
" lors de la lecture du nombre de mailles",NULL);
761 fprintf (stdout,
"- Nombre de mailles de type %s : "IFORMAT" \n",geotypename, _nmailles);
767 const char *
const nommaa,
772 const char*
const geotypename,
773 const med_int *
const nmailles,
802 void *_attvalue=NULL;
803 void (*_printf)(
const void*);
807 for (i=0; i<nmodels; i++ ) {
810 &_geotype,&_elementdim,
811 _supportmeshname,&_entitytype,&_nnode,&_ncell,
812 &_geocelltype,&_nconstantatribute,&_anyprofile,&_nvariableattribute);
815 taille=_ncell*_geocelltype%100;
825 connectivite = (
med_int*) calloc(taille*nmailles[i],
sizeof(
med_int));
826 EXIT_IF(connectivite == NULL,NULL,NULL);
827 nomele = (
char*) malloc(
sizeof(
char)*
MED_SNAME_SIZE*nmailles[i]+1);
828 EXIT_IF(nomele == NULL,NULL,NULL);
830 EXIT_IF(numele == NULL,NULL,NULL);
832 EXIT_IF(nufael == NULL,NULL,NULL);
837 &inoele,nomele,&inuele,numele,&inufael,nufael );
839 EXIT_IF(_ret < 0,
"lors de la lecture des mailles",NULL);
843 fprintf(stdout,
"\n(***************************************)\n");
844 fprintf(stdout,
"(* ELEMENTS DE STRUCTURE DU MAILLAGE : *)\n");
845 fprintf(stdout,
"(***************************************)\n");
850 fprintf(stdout,
"\n- Mailles de type %s : ", &geotypename[i*(
MED_NAME_SIZE+1)]);
851 if (strcmp(&geotypename[i*(
MED_NAME_SIZE+1)],
"MED_PARTICLE") ) {
852 fprintf(stdout,
"\n - Connectivité : ");
853 for (j=0;j<nmailles[i]*taille;j++) {
855 fprintf(stdout,
"\n [ %5"MED_IFORMAT" ] : ", (j/taille +1) );
857 fprintf(stdout,
"\n");
858 fprintf(stdout,
" %9"MED_IFORMAT" ",*(connectivite+j));
863 fprintf(stdout,
"\n - Noms : \n");
864 for (j=0;j<nmailles[i];j++) {
867 fprintf(stdout,
" %s ",
str);
871 fprintf(stdout,
"\n - Numeros :\n");
872 for (j=0;j<nmailles[i];j++)
873 fprintf(stdout,
" "IFORMAT" ",*(numele+j));
875 fprintf(stdout,
"\n - Numéros de familles : \n");
876 for (j=0;j<nmailles[i];j++)
878 fprintf(stdout,
" "IFORMAT" ",*(nufael+j));
880 fprintf(stdout,
" %d ",0);
881 fprintf(stdout,
"\n");
886 for (k=0; k<_nvariableattribute; k++) {
890 _attname, &_atttype, &_nattcomp);
891 EXIT_IF(_ret < 0,
"lors de la lecture des caractéristiques de attributs variables",NULL);
895 EXIT_IF(_atttype ==
MED_ATT_UNDEF,
"à la lecture du type (valeur : MED_ATT_UNDEF) de l'attribut variable ",_attname);
898 _attvaluesize = nmailles[i]*_nattcomp*_atttypesize;
900 _attvalue = (
void *) malloc( _attvaluesize*
sizeof(
char));
905 *(geotype+i), _attname, _attvalue );
906 if (_ret < 0 ) free(_attvalue);
907 EXIT_IF(_ret < 0,
"lors de la lecture des attributs variables",NULL);
912 fprintf(stdout,
"\n - Valeurs de l'attribut |%s| pour le type géométrique |%s| : \n",_attname,
914 for (j=0;j<nmailles[i]*_nattcomp;j++) {
915 if ( ( _nattcomp > 1 ) && !(j % _nattcomp) )
916 fprintf(stdout,
"\n [ %5"MED_IFORMAT" ] : ", (j/_nattcomp +1) );
917 _printf( (
void *)( (
char *)(_attvalue) + j*_atttypesize) );
940 const med_int *
const nmailles,
960 if (nmailles[i] > 0) {
963 EXIT_IF(ret < 0,
"lors de la lecture des caractéristiques des mailles",NULL);
979 connectivite = (
med_int*) malloc(
sizeof(
med_int)*taille*nmailles[i]);
980 EXIT_IF(connectivite == NULL,NULL,NULL);
981 nomele = (
char*) malloc(
sizeof(
char)*
MED_SNAME_SIZE*nmailles[i]+1);
982 EXIT_IF(nomele == NULL,NULL,NULL);
984 EXIT_IF(numele == NULL,NULL,NULL);
986 EXIT_IF(nufael == NULL,NULL,NULL);
990 typ_con, mode_coo, connectivite,
991 &inoele,nomele,&inuele,numele,&inufael,nufael );
993 EXIT_IF(ret < 0,
"lors de la lecture des mailles",NULL);
996 fprintf(stdout,
"\n(**************************)\n");
997 fprintf(stdout,
"(* ELEMENTS DU MAILLAGE : *)\n");
998 fprintf(stdout,
"(**************************)\n");
1003 fprintf(stdout,
"\n- Mailles de type %s : ",
nommai[i]);
1004 fprintf(stdout,
"\n - Connectivité : ");
1005 for (j=0;j<nmailles[i]*taille;j++) {
1007 fprintf(stdout,
"\n [ %5"MED_IFORMAT" ] : ", (j/taille +1) );
1009 fprintf(stdout,
"\n");
1010 fprintf(stdout,
" %9"MED_IFORMAT" ",*(connectivite+j));
1014 fprintf(stdout,
"\n - Noms : \n");
1015 for (j=0;j<nmailles[i];j++) {
1018 fprintf(stdout,
" %s ",
str);
1022 fprintf(stdout,
"\n - Numeros :\n");
1023 for (j=0;j<nmailles[i];j++)
1024 fprintf(stdout,
" "IFORMAT" ",*(numele+j));
1026 fprintf(stdout,
"\n - Numéros de familles : \n");
1027 for (j=0;j<nmailles[i];j++)
1029 fprintf(stdout,
" "IFORMAT" ",*(nufael+j));
1031 fprintf(stdout,
" %d ",0);
1032 fprintf(stdout,
"\n");
1047 const char *
const nommaa,
1067 EXIT_IF(nmpolygones < 0,
"lors de la lecture du nombre de mailles polygone\n",
1069 if (nmpolygones > 0 ) nmpolygones--;
else nmpolygones=0;
1072 fprintf(stdout,
"- Nombre de mailles de type %s : "IFORMAT" \n",
1073 polytypename,nmpolygones);
1075 polytypename[0]=
'\0';
1080 const char *
const nommaa,
1112 EXIT_IF(taille < 0,
"lors de la lecture des parametres des mailles polygones",
1117 EXIT_IF(indexp == NULL,NULL,NULL);
1119 EXIT_IF(connectivite == NULL,NULL,NULL);
1121 EXIT_IF(numele == NULL,NULL,NULL);
1123 EXIT_IF(nufael == NULL,NULL,NULL);
1124 nomele = (
char *) malloc(
sizeof(
char)*
MED_SNAME_SIZE*nmpolygones+1);
1125 EXIT_IF(nomele == NULL,NULL,NULL);
1129 indexp,connectivite);
1131 EXIT_IF(ret < 0,
"lors de la lecture des connectivites des mailles polygones",
1149 fprintf(stdout,
"\n\n- Mailles de type %s : ",polytypename);
1150 for (i=0;i<nmpolygones;i++) {
1151 fprintf(stdout,
"\n >> Maille MED_POLYGONE "IFORMAT" : \n",i+1);
1152 fprintf(stdout,
"\n - Connectivité : ");
1153 ind1 = *(indexp+i)-1;
1154 ind2 = *(indexp+i+1)-1;
1155 for (j=ind1;j<ind2;j++)
1156 printf(
" "IFORMAT" ",*(connectivite+j));
1160 fprintf(stdout,
"\n - Nom : %s \n",tmp);
1163 fprintf(stdout,
"\n - Numero : "IFORMAT" \n",*(numele+i));
1166 fprintf(stdout,
"\n - Numéro de famille : "IFORMAT" \n",*(nufael+i));
1168 fprintf(stdout,
"\n - Numéro de famille : %d \n",0);
1170 polytypename[0]=
'\0';
1185 const char *
const nommaa,
1196 EXIT_IF(npolyedres < 0,
"lors de la lecture du nombre de mailles polyedre \n",
1198 if ( npolyedres > 0 ) npolyedres--;
else npolyedres=0;
1200 fprintf(stdout,
"- Nombre de mailles de type MED_POLYEDRE : "IFORMAT" \n",
1208 const char *
const nommaa,
1236 EXIT_IF(taille < 0,
"lors de la lecture des parametres des mailles polyedres",
1242 EXIT_IF(nindn < 0,
"lors de la lecture des parametres des mailles polyedres",
1248 EXIT_IF(indexf == NULL,NULL,NULL);
1250 EXIT_IF(indexn == NULL,NULL,NULL);
1252 EXIT_IF(connectivite == NULL,NULL,NULL);
1254 EXIT_IF(numele == NULL,NULL,NULL);
1256 EXIT_IF(nufael == NULL,NULL,NULL);
1257 nomele = (
char *) malloc(
sizeof(
char)*
MED_SNAME_SIZE*npolyedres+1);
1258 EXIT_IF(nomele == NULL,NULL,NULL);
1261 indexf,indexn,connectivite);
1263 "lors de la lecture de la connectivite des mailles polyedres",
1277 fprintf(stdout,
"\n\n- Mailles de type MED_POLYEDRE : ");
1278 for (i=0;i<npolyedres;i++) {
1279 fprintf(stdout,
"\n >> Maille MED_POLYEDRE "IFORMAT" : \n",i+1);
1280 fprintf(stdout,
"\n - Connectivité : \n");
1281 nfa = *(indexf+i+1) - *(indexf+i);
1283 ind1 = *(indexf+i) - 1;
1284 for (j=0;j<nfa;j++) {
1288 ind2 = *(indexn+ind1+j) - 1;
1289 nnoe = *(indexn+ind1+j+1) - *(indexn+ind1+j);
1290 fprintf(stdout,
" - Face "IFORMAT" : [ ", j+1);
1291 for (k=0;k<nnoe;k++)
1292 printf(
" "IFORMAT" ",*(connectivite+ind2+k));
1296 nfa = *(indexf+i+1) - *(indexf+i);
1299 ind1 = *(indexf+i) - 1;
1302 *(connectivite+ind1+j),*(indexn+ind1+j));
1308 fprintf(stdout,
"\n - Nom : %s \n",tmp);
1311 fprintf(stdout,
"\n - Numero : "IFORMAT" \n",*(numele+i));
1313 fprintf(stdout,
"\n - Numéro de famille : "IFORMAT" \n",*(nufael+i));
1315 fprintf(stdout,
"\n - Numéro de famille : %d \n",0);
1332 const char *
const nommaa,
1345 EXIT_IF(nfaces < 0,
"lors de la lecture du nombre de faces",NULL);
1350 fprintf (stdout,
"- Nombre de faces de type %s : "IFORMAT" \n",
1357 const char *
const nommaa,
1377 if (nfaces[i] > 0 ) {
1381 EXIT_IF(ret < 0,
"lors de la lecture des caractéristiques des mailles",NULL);
1384 connectivite = (
med_int*)malloc(
sizeof(
med_int)*taille*nfaces[i]);
1385 EXIT_IF(connectivite == NULL,NULL,NULL);
1387 EXIT_IF(nomele == NULL,NULL,NULL);
1389 EXIT_IF(numele == NULL,NULL,NULL);
1391 EXIT_IF(nufael == NULL,NULL,NULL);
1396 &inoele,nomele,&inuele,numele,&inufael,nufael );
1397 EXIT_IF(ret < 0,
"lors de la lecture des faces",NULL);
1401 fprintf(stdout,
"\n- Faces de type %s : ",
nomfac[i]);
1402 fprintf(stdout,
"\n - Connectivité : ");
1403 for (j=0;j<nfaces[i]*taille;j++) {
1405 fprintf(stdout,
"\n [ %5"MED_IFORMAT" ] : ", (j/taille+1) );
1407 fprintf(stdout,
"\n");
1408 fprintf(stdout,
" %9"MED_IFORMAT" ",*(connectivite+j));
1412 fprintf(stdout,
"\n - Noms : \n");
1413 for (j=0;j<nfaces[i];j++) {
1416 fprintf(stdout,
" %s ",
str);
1420 fprintf(stdout,
"\n - Numeros :\n");
1421 for (j=0;j<nfaces[i];j++)
1422 fprintf(stdout,
" "IFORMAT" ",*(numele+j));
1424 fprintf(stdout,
"\n - Numéros de familles : \n");
1425 for (j=0;j<nfaces[i];j++)
1427 fprintf(stdout,
" "IFORMAT" ",*(nufael+j));
1429 fprintf(stdout,
" %d ",0);
1443 const char *
const nommaa,
1454 EXIT_IF(nfpolygones < 0,
"lors de la lecture du nombre de faces polygone \n",
1456 if (nfpolygones > 0 ) nfpolygones--;
else nfpolygones=0;
1458 fprintf(stdout,
"- Nombre de faces de type MED_POLYGONE : "IFORMAT" \n",
1465 const char *
const nommaa,
1488 EXIT_IF(taille < 0,
"lors de la lecture des parametres des faces polygones",
1493 EXIT_IF(indexp == NULL,NULL,NULL);
1495 EXIT_IF(connectivite == NULL,NULL,NULL);
1497 EXIT_IF(numele == NULL,NULL,NULL);
1499 EXIT_IF(nufael == NULL,NULL,NULL);
1500 nomele = (
char *) malloc(
sizeof(
char)*
MED_SNAME_SIZE*nfpolygones+1);
1501 EXIT_IF(nomele == NULL,NULL,NULL);
1505 indexp,connectivite);
1506 EXIT_IF(ret < 0,
"lors de la lecture des connectivites des faces polygones", NULL);
1522 fprintf(stdout,
"\n\n- Faces de type MED_POLYGONE : ");
1523 for (i=0;i<nfpolygones;i++) {
1524 fprintf(stdout,
"\n >> Face MED_POLYGONE "IFORMAT" : \n",i+1);
1525 fprintf(stdout,
"\n - Connectivité : ");
1526 ind1 = *(indexp+i)-1;
1527 ind2 = *(indexp+i+1)-1;
1528 for (j=ind1;j<ind2;j++)
1529 fprintf(stdout,
" "IFORMAT" ",*(connectivite+j));
1533 fprintf(stdout,
"\n - Nom : %s \n",tmp);
1536 fprintf(stdout,
"\n - Numero : "IFORMAT" \n",*(numele+j));
1538 fprintf(stdout,
"\n - Numéro de famille : "IFORMAT" \n",*(nufael+i));
1540 fprintf(stdout,
"\n - Numéro de famille : %d \n",0);
1556 const char *
const nommaa,
1568 EXIT_IF(naretes < 0,
"lors de la lecture du nombre d'aretes",NULL);
1573 "- Nombre d'aretes de type %s : "IFORMAT" \n",
nomare[indice],naretes);
1579 const char *
const nommaa,
1583 const med_int *
const naretes,
1599 if (naretes[i] > 0) {
1602 EXIT_IF(ret < 0,
"lors de la lecture des caractéristiques des mailles",NULL);
1605 connectivite = (
med_int*)malloc(
sizeof(
med_int)*taille*naretes[i]);
1606 EXIT_IF(connectivite == NULL,NULL,NULL);
1607 nomele = (
char*)malloc(
sizeof(
char)*
MED_SNAME_SIZE*naretes[i]+1);
1608 EXIT_IF(nomele == NULL,NULL,NULL);
1610 EXIT_IF(numele == NULL,NULL,NULL);
1612 EXIT_IF(nufael == NULL,NULL,NULL);
1617 &inoele,nomele,&inuele,numele,&inufael,nufael );
1618 EXIT_IF(ret < 0,
"lors de la lecture des aretes",
1623 fprintf(stdout,
"\n- Aretes de type %s : ",
nomare[i]);
1624 fprintf(stdout,
"\n - Connectivité : ");
1625 for (j=0;j<naretes[i]*taille;j++) {
1627 fprintf(stdout,
"\n [ %5"MED_IFORMAT" ] : ", (j/taille+1) );
1629 fprintf(stdout,
"\n");
1630 fprintf(stdout,
" %9"MED_IFORMAT" ",*(connectivite+j));
1634 fprintf(stdout,
"\n - Noms : \n");
1635 for (j=0;j<naretes[i];j++) {
1638 fprintf(stdout,
" %s ",
str);
1642 fprintf(stdout,
"\n - Numeros :\n");
1643 for (j=0;j<naretes[i];j++)
1644 fprintf(stdout,
" "IFORMAT" ",*(numele+j));
1646 fprintf(stdout,
"\n - Numéros de familles : \n");
1647 for (j=0;j<naretes[i];j++)
1649 fprintf(stdout,
" "IFORMAT" ",*(nufael+j));
1651 fprintf(stdout,
" %d ",0);
1689 const char *
const nomcoo,
1690 const char *
const unicoo,
1694 char** geotypename_elst,
1695 const int lecture_en_tete_seulement)
1704 med_int nmpolygones,nmpolygones2, npolyedres, nfpolygones;
1712 med_int _nmodels=0,*_nmailles_elst = NULL;
1714 char *_geotypename_elst = NULL;
1725 "Erreur à la lecture du nombre de type géométrique pour le type d'entités MED_STRUCT_ELEMENT",NULL);
1729 _geotypename_elst = (
char *) malloc(_nmodels*
sizeof(
char)*(
MED_NAME_SIZE+1));
1731 for (i=0; i < _nmodels; i++) {
1736 *nmodels = _nmodels;
1737 *geotype_elst = _geotype_elst;
1738 *geotypename_elst = _geotypename_elst;
1794 lecture_noeuds_maillage_non_structure(fid,nommaa,numdt,numit,mdim,edim,nnoe,mode_coo,nomcoo,unicoo,rep);
1818 _geotype_elst,_geotypename_elst,_nmailles_elst,mode_coo);
1827 if (nmpolygones > 0)
1831 if (nmpolygones2 > 0)
1842 if (nfpolygones > 0)
1877 const char *
const nommaa,
1895 EXIT_IF(ret < 0,
"a la lecture du type d'une grille ",NULL);
1902 fprintf(stdout,
"- Type de grille : MED_GRILLE_CARTESIENNE \n");
1904 fprintf(stdout,
"- Type de grille : MED_GRILLE_POLAIRE \n");
1905 for (axe=1;axe<=mdim;axe++) {
1924 "lors de la lecture de la taille d'un indice d'une grille",
1926 *nnoe = nind[axe - 1] * (*nnoe);
1927 *nmai = (nind[axe - 1] - 1) * (*nmai);
1929 "- Taille de l'indice de l'axe "IFORMAT" des coordonnees : "IFORMAT" \n",
1935 fprintf(stdout,
"- Type de grille : MED_GRILLE_DESTRUCTUREE \n");
1938 EXIT_IF(*nnoe < 0,
"lors de la lecture du nombre de noeuds du maillage "
1943 EXIT_IF(structure_grille == NULL,NULL,NULL);
1947 EXIT_IF(ret < 0,
"lors de la lecture de la structure de la grille",
1949 fprintf(stdout,
"- Structure de la grille : [ ");
1950 for (j=0;j<mdim;j++) {
1951 *nmai = (*(structure_grille+j) - 1) * (*nmai);
1952 fprintf(stdout,
" "IFORMAT" ",*(structure_grille+j));
1954 fprintf(stdout,
" ] \n");
1956 free(structure_grille);
1961 EXIT_IF(-1,
"Type de grille non reconnu.",nommaa);
1965 fprintf(stdout,
"- Nombre de noeuds : "IFORMAT" \n",*nnoe);
1966 fprintf(stdout,
"- Nombre de mailles : "IFORMAT" \n",*nmai);
1973 const char *
const nommaa,
1980 const char *
const comp,
1981 const char *
const unit,
1992 char *nomnoe = NULL;
1995 fprintf(stdout,
"\n(*************************)\n");
1996 fprintf(stdout,
"(* NOEUDS DE LA GRILLE : *)\n");
1997 fprintf(stdout,
"(*************************)\n");
2004 for (axe = 1; axe<=mdim; axe++) {
2007 EXIT_IF(indices == NULL,NULL,NULL);
2011 EXIT_IF(ret < 0,
"lors de la lecture d'un tableau d'indice",
2015 for (j=0;j<nind[axe - 1];j++)
2016 fprintf(stdout,
" %f ",*(indices+j));
2026 EXIT_IF(coo == NULL,NULL,NULL);
2030 EXIT_IF(ret < 0,
"lors de la lecture des noeuds du maillage",NULL);
2032 fprintf(stdout,
"- Nom des coordonnees : \n");
2033 for (i=0;i<edim;i++) {
2036 fprintf(stdout,
" %s ",
str);
2038 fprintf(stdout,
"\n- Unites des coordonnees : \n");
2039 for (i=0;i<edim;i++) {
2042 fprintf(stdout,
" %s ",
str);
2045 fprintf(stdout,
"\n - Coordonnees des noeuds : [ ");
2046 for (j=0;j<nnoe*edim;j++)
2047 fprintf(stdout,
" %f ",*(coo+j));
2048 fprintf(stdout,
" ] \n");
2057 EXIT_IF(-1,
"Type de grille non reconnu.",nommaa);
2068 EXIT_IF(numnoe == NULL,NULL,NULL);
2070 EXIT_IF(nomnoe == NULL,NULL,NULL);
2072 EXIT_IF(nufano == NULL,NULL,NULL);
2076 if (ret < 0) ret=0;
else inufael=
MED_TRUE;
2078 EXIT_IF(ret < 0,
"lors de la lecture des numeros de familles des noeuds",
2082 fprintf(stdout,
"\n- Numeros des familles des noeuds : \n");
2083 for (i=0;i<nnoe;i++)
2085 fprintf(stdout,
" "IFORMAT" ",*(nufano+i));
2087 fprintf(stdout,
" %d ",0);
2088 fprintf(stdout,
"\n");
2094 fprintf(stdout,
"\n- Noms des noeuds : \n");
2095 for (i=0;i<nnoe;i++) {
2098 fprintf(stdout,
" %s ",
str);
2106 fprintf(stdout,
"\n- Numeros des noeuds : \n");
2107 for (i=0;i<nnoe;i++)
2108 fprintf(stdout,
" "IFORMAT" ",*(numnoe+i));
2122 const char *
const nommaa,
2132 char *nomele = NULL;
2138 fprintf(stdout,
"\n(***************************)\n");
2139 fprintf(stdout,
"(* ELEMENTS DE LA GRILLE : *)\n");
2140 fprintf(stdout,
"(***************************)\n");
2165 EXIT_IF(numele == NULL,NULL,NULL);
2167 EXIT_IF(nomele == NULL,NULL,NULL);
2169 EXIT_IF(nufael == NULL,NULL,NULL);
2174 for (i=0;i<nmai;i++)
2179 fprintf(stdout,
"\n- Numeros des familles des mailles : \n");
2180 for (i=0;i<nmai;i++)
2181 fprintf(stdout,
" "IFORMAT" ",*(nufael+i));
2182 fprintf(stdout,
"\n");
2188 fprintf(stdout,
"\n - Noms : \n");
2189 for (i=0;i<nmai;i++) {
2192 fprintf(stdout,
" %s ",
str);
2200 fprintf(stdout,
"\n - Numeros :\n");
2201 for (i=0;i<nmai;i++)
2202 fprintf(stdout,
" "IFORMAT" ",*(numele+i));
2215 const char *
const nommaa,
2221 const char *
const comp,
2222 const char *
const unit,
2223 const int lecture_en_tete_seulement)
2254 if (lecture_en_tete_seulement)
2260 lecture_noeuds_maillage_structure(fid,nommaa,numdt,numit,mdim,edim,nind,nnoe,comp,unit,type,mode_coo);
2286 const char *
const maillage,
2291 const char*
const geotypename_elst,
2292 const char *
const nomcha,
2293 const char *
const dtunit,
2296 const char *
const comp,
2297 const char *
const unit,
2302 int i,j,k,l,m,n,nb_geo=0;
2303 med_int nbpdtnor=0,pflsize,*pflval,ngauss=0,ngroup,nval;
2304 unsigned char *val = NULL;
2305 med_int numdt=0,numo=0,_nprofile;
2306 med_int meshnumdt=0,meshnumit=0;
2323 char * * AFF_lgeotype = NULL;
2325 size_t _bannerlen=255;
2326 size_t _bannerlen1=0,_bannershift1=0;
2328 char * _bannerstr1=NULL;
2329 size_t _bannerlen2=0,_bannershift2=0;
2331 char * _bannerstr2=NULL;
2333 const char *
const * AFF;
2335 const char * * AFF_STRUCT = NULL;
2360 AFF_STRUCT = (
const char * *) calloc(
sizeof(
const char * ),nmodels+1);
2361 for(i=0;i<nmodels;++i) AFF_STRUCT[i+1]= &geotypename_elst[(
MED_NAME_SIZE+1)*i];
2393 type_geo = _lgeotype;
2394 AFF_lgeotype = (
char * *) calloc(_ngeo+1,
sizeof(
char * ));AFF_lgeotype[0]=
MED_NULL;
2395 for(i=1;i<=_ngeo;++i) {
2399 AFF = (
const char * *) AFF_lgeotype;
2402 for (k=1;k<=_ngeo;k++) {
2406 if (nbpdtnor < 1 )
continue;
2408 for (j=0;j<nbpdtnor;j++) {
2411 &nmesh, maa_ass, &localmesh, &meshnumdt, &meshnumit ) <0) {
2412 MESSAGE(
"Erreur a la demande d'information sur (pdt,nor) : ");
2418 for (i=0;i< nmesh;++i) {
2421 meshname,pflname,locname ) ) < 0 ) {
2422 MESSAGE(
"Erreur a la demande du nombre de profils referencés par le champ : ");
2429 for (l=0;l<_nprofile;l++) {
2433 locname, &ngauss) ) < 0 ) {
2434 MESSAGE(
"Erreur a la lecture du nombre de valeurs du champ : ");
2444 if ( ( (!strcmp(meshname,maillage)) && (meshnumdt == mnumdt) && (meshnumit == mnumit)) ||
2445 ( !strlen(maillage) )
2449 _bannerstr1 =
"(* CHAMP |%s| A L'ÉTAPE DE CALCUL (n°dt,n°it)="
2452 _bannerstr2 =
"(* SUR LE MAILLAGE |%s| A L'ÉTAPE DE CALCUL (n°dt,n°it)="
2454 snprintf(_temp1,
MAXBANNERLEN+1,_bannerstr1,nomcha,numdt,numo,0,
"");
2455 snprintf(_temp2,
MAXBANNERLEN+1,_bannerstr2,meshname,meshnumdt,meshnumit,0,
"");
2456 _bannerlen1 = strlen(_temp1);
2457 _bannerlen2 = strlen(_temp2);
2458 _bannerlen=
MAX(_bannerlen1,_bannerlen2);
2459 if (_bannerlen1>_bannerlen2) {
2460 _bannershift1 = 0; _bannershift2 = _bannerlen1-_bannerlen2;
2462 _bannershift2 = 0; _bannershift1 = _bannerlen2-_bannerlen1;
2464 fprintf(stdout,
"\n(");
2465 for (i=0;i< _bannerlen-6; i++) fprintf(stdout,
"*");
2466 fprintf(stdout,
")\n");
2467 fprintf(stdout,_bannerstr1,nomcha,numdt,numo,_bannershift1,
MED_NAME_BLANK);
2468 fprintf(stdout,_bannerstr2,meshname,meshnumdt,meshnumit,_bannershift2,
MED_NAME_BLANK);
2469 fprintf(stdout,
"(");
2470 for (i=0;i< _bannerlen-6; i++) fprintf(stdout,
"*");
2471 fprintf(stdout,
")\n");
2483 fprintf(stdout,
"- Valeur de la date du champ %f [%s] : \n",dt,dtunit);
2484 fprintf(stdout,
"- Type des composantes du champ : %d\n",typcha);
2485 fprintf(stdout,
"- Nombre de composantes par valeur : "IFORMAT"\n",ncomp);
2486 fprintf(stdout,
"- Unité des composantes : |%s|\n",unit);
2487 fprintf(stdout,
"- Nom des composantes : |%s|\n",comp);
2489 printf(
"\t- Il y a "IFORMAT" entités qui portent des valeurs en mode %i."
2490 "\n\t Chaque entite %s de type geometrique %s associes au profil |%s| a "IFORMAT" point(s) d'intégration \n",
2491 nval,
USER_MODE,AFF_ENT[(
int)entite],AFF[k],pflname,ngauss);
2497 MESSAGE(
"Erreur a la lecture de la taille du lien : ");
2501 lien = (
char *)malloc(lnsize*
sizeof(
char) + 1);
2502 EXIT_IF(lien == NULL,NULL,NULL);
2504 if (
MEDlinkRd(fid, maa_ass, lien) < 0 ) {
2505 MESSAGE(
"Erreur a la lecture du lien : ");
2509 lien[lnsize] =
'\0';
2510 printf(
"\tLe maillage |%s| est porte par un fichier distant |%s|\n",maa_ass,lien);
2524 MESSAGE(
"Erreur a la lecture du type de champ : ");
2526 EXIT_IF(NULL == NULL,NULL,NULL);
2529 val = (
unsigned char*) calloc(ncomp*nval*ngauss,medtype_size);
2530 EXIT_IF(val == NULL,NULL,NULL);
2535 (
unsigned char*) val) < 0 ) {
2536 MESSAGE(
"Erreur a la lecture des valeurs du champ : ");
2542 if ( strlen(locname) && (_nprofile > 1) )
2543 printf(
"\t- Modèle de localisation des points de Gauss de nom |%s|\n",locname);
2546 ngroup = (type_geo[k] % 100);
2554 printf(
"\t- Valeurs :\n\t");
2555 for (m=0;m<(nval*ngauss)/ngroup;m++) {
2557 for (n=0;n<ngroup*ncomp;n++)
2560 printf(
" %f ",*(((
med_double*)val)+(m*ngroup*ncomp)+n ) );
2565 printf(
" %f ",*(((
med_float32*)val)+((m*ngroup*ncomp)+n)));
2568 printf(
" %d ",*(((
med_int32*)val)+(m*ngroup*ncomp)+n));
2571 printf(
" %ld ",*(((
med_int64*)val)+(m*ngroup*ncomp)+n));
2587 printf(
"\t- Valeurs :\n\t");
2588 for (m=0;m<ncomp;m++) {
2590 for (n=0;n<(nval*ngauss);n++)
2593 printf(
" %f ",*(((
med_double*)val)+(m*nval*ngauss)+n ) );
2598 printf(
" %f ",*(((
med_float32*)val)+((m*nval*ngauss)+n)));
2601 printf(
" %d ",*(((
med_int32*)val)+(m*nval*ngauss)+n));
2604 printf(
" %ld ",*(((
med_int64*)val)+(m*nval*ngauss)+n));
2621 if ( val ) {free(val);val = NULL;}
2625 printf(
"\t- Profil : MED_NOPFL\n");
2628 MESSAGE(
"Erreur a la lecture du nombre de valeurs du profil : ");
2633 printf(
"\t- Profil : |%s| de taille "IFORMAT"\n",pflname,pflsize);
2636 EXIT_IF(pflval == NULL,NULL,NULL);
2638 MESSAGE(
"Erreur a la lecture des valeurs du profil : ");
2644 for (m=0;m<pflsize;m++) printf(
" "IFORMAT" ",*(pflval+m));
2655 for(i=1;i<=_ngeo;++i) free(AFF_lgeotype[i]);
2677 const char *
const maillage,
2683 const char* geotypename_elst,
2684 const int lecture_en_tete_seulement)
2702 EXIT_IF(ncha < 0,
"lors de la lecture du nombre de champs",NULL);
2704 if ( !strlen(maillage) || lecture_en_tete_seulement ) {
2705 fprintf(stdout,
"\n(************************)\n");
2706 fprintf(stdout,
"(* CHAMPS RESULTATS : *)\n");
2707 fprintf(stdout,
"(************************)\n");
2708 fprintf(stdout,
"- Nombre de champs : "IFORMAT" \n",ncha);
2717 for (i =0;i<ncha;i++) {
2722 MESSAGE(
"Erreur à la lecture du nombre de composantes : ");
2730 EXIT_IF(comp == NULL,NULL,NULL);
2732 EXIT_IF(unit == NULL,NULL,NULL);
2735 &typcha, comp, unit, dtunit, &ncstp) < 0 ) {
2736 MESSAGE(
"Erreur à la demande d'information sur les champs : ");
2741 if ( !strlen(maillage) || lecture_en_tete_seulement ) {
2742 printf(
"\nChamp numero : |%d| \n",i+1);
2743 printf(
"Nom du champ : |%s| de type |%d|\n",nomcha,typcha);
2744 printf(
"Nom des composantes : |%s|\n",comp);
2745 printf(
"Unites des composantes : |%s| \n",unit);
2747 printf(
"Unité des dates : |%s|\n",dtunit);
2749 printf(
"Nombre d'étapes de calcul : |"IFORMAT"| \n",ncstp);
2753 if (lecture_en_tete_seulement) {
2764 for (j=0; j < _nentity ; j++) {
2766 lret =
getFieldsOn(fid, maillage, mnumdt, mnumit, nmodels,geotype_elst,geotypename_elst,
2767 nomcha, dtunit, typcha, ncomp, comp, unit,_lentitytype[j],mode_coo, ncstp);
2824 int lecture_en_tete_seulement)
2840 EXIT_IF(n < 0,
"lors de la lecture du nombre de scalaires",NULL);
2843 fprintf(stdout,
"\n(*******************************)\n");
2844 fprintf(stdout,
"(* VARIABLES SCALAIRES : *)\n");
2845 fprintf(stdout,
"(*******************************)\n\n");
2846 fprintf(stdout,
"- Nombre de variables scalaires : "IFORMAT"\n",n);
2848 if (lecture_en_tete_seulement)
2851 for (i=1;i<=n;i++) {
2856 EXIT_IF(ret < 0,
"lors de la lecture des parametres d'un scalaire",NULL);
2857 fprintf(stdout,
"- Scalaire n°"IFORMAT" de nom %s \n",i,nom_scalaire);
2859 fprintf(stdout,
" Type flottant. \n");
2861 fprintf(stdout,
" Type entier. \n");
2862 printf(
" Description associee : [%s] \n",description);
2867 "lors de la lecture du nombre de pas de temps d'un scalaire"
2869 fprintf(stdout,
" Nombre de valeurs stockees : "IFORMAT" \n",npdt);
2871 for (j=1;j<=npdt;j++) {
2875 "lors de la lecture des parametres d'un pas de temps d'un scalaire",
2879 fprintf(stdout,
" - Aucun de pas de temps \n");
2882 " - Pas de de temps de numero "IFORMAT" de valeur %f [%s] \n",numdt,
2885 fprintf(stdout,
" - Aucun numero d'ordre \n");
2887 fprintf(stdout,
" - Numero d'ordre : "IFORMAT" \n",numo);
2891 fprintf(stdout,
" - Valeur : %f \n",valr);
2895 fprintf(stdout,
" - Valeur : "IFORMAT" \n",vali);
2897 EXIT_IF(ret < 0,
"lors de la lecture de la valeur d'un scalaire",NULL);
2917 int lecture_en_tete_seulement)
2927 EXIT_IF(npro < 0,
"lors de la lecture du nombre de profils",NULL);
2930 fprintf(stdout,
"\n(*************)\n");
2931 fprintf(stdout,
"(* PROFILS : *)\n");
2932 fprintf(stdout,
"(*************)\n");
2933 printf(
"\nNombre de profils stockes : "IFORMAT"\n\n",npro);
2936 for (i=1 ; i <= npro ; i++ ) {
2941 printf(
"\t- Profil n°%i de nom |%s| et de taille "IFORMAT"\n",i,pflname,nval);
2944 MESSAGE(
"Erreur a la lecture des valeurs du profil : ");
2950 for (j=0;j<nval;j++) printf(
" "IFORMAT" ",*(pflval+j));
2971 int lecture_en_tete_seulement)
2974 int _i =0,_j=0,_k=0, _n=0,_nvalue=0;
2987 med_int _nconstantattribute=0;
2989 med_int _nvariableattribute=0;
3000 unsigned char * _value=NULL;
3001 void (*_printf)(
const void*);
3005 EXIT_IF(_nstructelement < 0,
"lors de la lecture du nombre d'éléments de structure",NULL);
3007 if(_nstructelement) {
3008 fprintf(stdout,
"\n(*************************************)\n");
3009 fprintf(stdout,
"(* MODELES D'ELEMENTS DE STRUCTURE : *)\n");
3010 fprintf(stdout,
"(*************************************)\n");
3011 printf(
"\nNombre d'éléments de structure : "IFORMAT"\n\n",_nstructelement);
3014 for ( _i=1; _i<= _nstructelement; ++_i) {
3017 &_entitytype,&_nnode,&_ncell,&_geocelltype,&_nconstantattribute,&_anyprofile,
3018 &_nvariableattribute );
3019 EXIT_IF(_ret < 0,
"lors de la demande d'information sur les éléments de structure",NULL);
3021 fprintf(stdout,
"\nElément de structure n°%d |%s| de type géométrique n°%d et de dimension "IFORMAT"\n",
3022 _i,_elementname,_geotype,_elementdim);
3023 if ( strlen(_supportmeshname) ) {
3024 fprintf(stdout,
"\t Maillage support de nom |%s|",_supportmeshname);
3027 fprintf(stdout,
" avec "IFORMAT" maille(s) de type |%s| et",_ncell,_geocelltypename);
3030 fprintf(stdout,
" avec "IFORMAT" noeud(s)\n",_nnode);
3032 fprintf(stderr,
"\n Erreur : les noeuds doivent être définis s'il existe un maillage support\n");
3035 fprintf(stdout,
"\t Maillage support implicite sur noeud\n");
3037 fprintf(stdout,
"\t Nombre d'attribut(s) constant(s) : "IFORMAT"",_nconstantattribute);
3038 if (_anyprofile) fprintf(stdout,
", avec profil.\n");
else fprintf(stdout,
", sans profil.\n");
3040 if ( _nconstantattribute ) {
3041 for (_j=1;_j<=_nconstantattribute;++_j) {
3043 _constattname, &_constatttype, &_ncomponent,
3044 &_attentitytype, _profilename, &_profilesize );
3045 EXIT_IF(_ret < 0,
"lors de la demande d'information sur les attributs constants des éléments de structure",NULL);
3047 fprintf(stdout,
"\t\t Attribut constant de nom |%s| de type %d à "IFORMAT" composantes\n",
3048 _constattname,_constatttype,_ncomponent);
3050 if (!_profilesize) {
3051 if (_attentitytype ==
MED_NODE) _nvalue = _nnode;
else _nvalue=_ncell;
3053 _nvalue = _profilesize;
3055 _n = _ncomponent*_nvalue;
3058 _value = (
unsigned char *) malloc(_n*_atttypesize);
3062 if (_ret < 0 ) free(_value);
3063 EXIT_IF(_ret < 0,
"lors de la lecture des valeurs des attributs constants",NULL);
3067 fprintf(stdout,
"\t\t - Valeurs de l'attribut sur les d'entité |%s|",
3070 fprintf(stdout,
" avec un profil |%s| de taille "IFORMAT": ",_profilename,_profilesize);
3072 fprintf(stdout,
" sans profil : ");
3074 for (_k=0;_k<_nvalue*_ncomponent;_k++) {
3076 if ( !(_k % _ncomponent) )
3077 fprintf(stdout,
"\n [ %5"MED_IFORMAT" ] : ", (_k/_ncomponent +1) );
3078 _printf( (
void *)( (
char *)(_value) + _k*_atttypesize) );
3088 fprintf(stdout,
"\t Nombre d'attribut(s) variable(s) : "IFORMAT"\n",_nvariableattribute);
3089 if ( _nvariableattribute ) {
3090 for (_j=1;_j<=_nvariableattribute;++_j) {
3092 EXIT_IF(_ret < 0,
"lors de la lecture des valeurs des attributs variables",NULL);
3093 fprintf(stdout,
"\t\t Attribut variable de nom |%s| de type %d à "IFORMAT" composantes\n",
3094 _varattname,_varatttype,_ncomponent);
3115 int lecture_en_tete_seulement)
3124 med_int _geodim=0,_geonnodes=0;
3130 int _basisfuncit =0;
3135 int _coefficientit =0;
3140 fprintf(stdout,
"\n(********************************)\n");
3141 fprintf(stdout,
"(* FONCTIONS D'INTERPOLATION : *)\n");
3142 fprintf(stdout,
"(********************************)\n");
3143 printf(
"\nNombre de fonctions d'interpolation : "IFORMAT"\n\n",_ninterp);
3146 for ( _interpit=1; _interpit<= _ninterp; ++_interpit) {
3148 if (
MEDinterpInfo(fid,_interpit,_interpname,&_geotype,&_cellnodes,&_nbasisfunc,
3149 &_nvariable,&_maxdegree,&_nmaxcoefficient) < 0 ) {
3150 MESSAGE(
"Erreur à la demande d'information de la fonction d'interpolation n°");
3156 fprintf(stdout,
"Fonction d'interpolation n° %d |%s| sur le type géométrique |%s|\n",
3157 _interpit,_interpname, _geotypename);
3165 if ( _nbasisfunc == _geonnodes )
3166 fprintf(stdout,
"\t Les noeuds de construction sont les noeuds de la maille de référence.\n");
3168 MESSAGE(
"Erreur : le nombre de noeuds de construction "\
3169 "est différent du nombre de noeuds de la maille de référence.\n");
3181 fprintf(stdout,
"\t Il y a "IFORMAT" fonctions de base avec "IFORMAT" variables\n ",_nbasisfunc,_nvariable);
3182 fprintf(stdout,
"\t Le degré maximum des fonctions de base est "IFORMAT" et possèdent au maximum "IFORMAT" coefficients\n"
3183 ,_maxdegree,_nmaxcoefficient);
3187 _power = (
med_int*) calloc(
sizeof(
med_int),_nvariable*_nmaxcoefficient);
3189 for ( _basisfuncit=1; _basisfuncit<= _nbasisfunc; ++_basisfuncit) {
3192 if ( (_ret =
MEDinterpBaseFunctionRd( fid,_interpname,_basisfuncit,&_ncoefficient,_power,_coefficient) <0) ) {
3198 fprintf(stdout,
"\n\t Tableau de coefficients de la fonctions de base n° %d :\n\t",_basisfuncit);
3199 for ( _coefficientit=1; _coefficientit<= _ncoefficient; ++_coefficientit)
3200 fprintf(stdout,
" %4f ",_coefficient[_coefficientit]);
3202 fprintf(stdout,
"\n\t Tableau de puissances de la fonctions de base n° %d :\n\t",_basisfuncit);
3203 for ( _powerit=1; _powerit<= _nvariable*_ncoefficient; ++_powerit)
3204 fprintf(stdout,
" %4"MED_IFORMAT" ",_power[_powerit]);
3208 fprintf(stdout,
"\n");
3229 int lecture_en_tete_seulement)
3242 fprintf(stdout,
"\n(***********)\n");
3243 fprintf(stdout,
"(* LIENS : *)\n");
3244 fprintf(stdout,
"(***********)\n");
3245 printf(
"\nNombre de liens : "IFORMAT"\n\n",nln);
3248 for (i=1 ; i <= nln ; i++ ) {
3253 printf(
"\t- Lien n°%i de nom |%s| et de taille "IFORMAT"\n",i,nomlien,nval);
3255 lien = (
char * ) malloc((nval+1)*
sizeof(char));
3256 EXIT_IF(lien == NULL,NULL,NULL);
3258 if (
MEDlinkRd(fid, nomlien, lien ) < 0 ) {
3259 MESSAGE(
"Erreur a la lecture du lien : ");
3264 printf(
"\t\t|%s|\n\n",lien);
3269 printf(
"Erreur au montage du lien : |%s|\n",lien);
3295 int lecture_en_tete_seulement)
3298 med_int nloc=0,locsdim=0,ngauss=0;
3300 med_float *refcoo=NULL, *gscoo=NULL, *wg=NULL;
3317 fprintf(stdout,
"\n(********************************************)\n");
3318 fprintf(stdout,
"(* LOCALISATIONS DES POINTS D'INTEGRATION : *)\n");
3319 fprintf(stdout,
"(********************************************)\n");
3320 printf(
"\nNombre de localisations stockees : "IFORMAT"\n\n",nloc);
3323 for (i=1 ; i <= nloc ; i++ ) {
3325 geointerpname, ipointstructmeshname, &nsectionmeshcell,
3326 §iongeotype) < 0) {
3327 MESSAGE(
"Erreur a la demande d'information sur la localisation n° : ");
ISCRUTE_int(i);
3330 printf(
"\t- Loc. n°%i de nom |%s| de dimension "IFORMAT" avec "IFORMAT" pts de GAUSS \n",i,locname,locsdim,ngauss);
3342 if (strlen(ipointstructmeshname)) {
3344 MESSAGE(
"Erreur à la lecture du nom associé au sectiongeotype : ");
ISCRUTE_int(sectiongeotype);
3345 SSCRUTE(ipointstructmeshname);
3350 t1 = locnnodes*locsdim;
3351 t2 = ngauss*locsdim;
3358 MESSAGE(
"Erreur a la lecture des valeurs de la localisation : ");
3363 printf(
"\t Coordonnees de l'element de reference de type |%s| :\n\t\t",_locgeotypename);
3365 for (j=0;j<locnnodes*locsdim;j++) {
3367 fprintf(stdout,
"\n [ %5"MED_IFORMAT" ] : ", (j/locsdim + 1) );
3369 fprintf(stdout,
"\n\n ");
3370 fprintf(stdout,
" %-+9.6f ",*(refcoo+j));
3373 printf(
"\t Localisation des points de GAUSS : \n\t\t");
3375 for (j=0;j<ngauss*locsdim;j++) {
3377 fprintf(stdout,
"\n [ %5"MED_IFORMAT" ] : ", (j/locsdim + 1) );
3379 fprintf(stdout,
"\n\n ");
3380 fprintf(stdout,
" %-+9.6f ",*(gscoo+j));
3383 printf(
"\t Poids associes aux points de GAUSS :\n\t\t");
3384 for (j=0;j<t3;j++) printf(
" %f ",*(wg+j));
3387 if (strlen(ipointstructmeshname)) {
3388 printf(
"\t Maillage support de section d'élément de structure |%s|.\n",ipointstructmeshname);
3389 printf(
"\t Mailles des sections d'élément de structure de type |%s|.\n",sectiongeotypename);
3390 printf(
"\t Nombre de mailles par section d'élément de structure : "IFORMAT".\n",nsectionmeshcell);
3392 if (strlen(geointerpname)) {
3393 printf(
"\t Tranformation géométrique associée à la localisation |%s|.\n",geointerpname);
3410 med_int majeur,mineur,release;
3415 ret = (int) access(fichier,F_OK);
3416 if (ret <0) {
SSCRUTE(fichier);}
3417 EXIT_IF(ret < 0,
"Le fichier n'est pas accessible ou n'existe pas ",
3422 EXIT_IF(ret < 0,
"Impossible de déterminer la compatibilité de format. ",
3425 EXIT_IF(!hdfok,
"Le fichier n'est pas dans un format HDF compatible ", fichier);
3426 EXIT_IF(!medok,
"Le fichier n'est pas dans un format MED compatible ", fichier);
3432 majeur,mineur,release);
3437 EXIT_IF( fid < 0,
"Ouverture du du fichier ",fichier);
3440 EXIT_IF(( (majeur < 2) || ( (majeur == 2) && (mineur < 2)) ),
"Le fichier est antérieur à la version 2.2", NULL);
3456 fprintf(stdout,
"- En-tete du fichier : %s \n",fichier_en_tete);
3467 fprintf(stdout,
"(*****************)\n");
3468 fprintf(stdout,
"(* PARAMETRAGE : *)\n");
3469 fprintf(stdout,
"(*****************)\n");
3470 fprintf(stdout,
"- Mode d'affichage des coordonnées des noeuds ? \n");
3471 fprintf(stdout,
" 1. Mode entrelacé : taper 1 \n");
3472 fprintf(stdout,
" 2. Mode non entrelacé : taper 2 \n");
3475 fprintf(stdout,
" Reponse : ");
3476 if (!scanf(
"%d",&reponse)) fgets(_temp, 256, stdin) ;
3477 }
while (reponse != 1 && reponse != 2);
3483 fprintf(stdout,
"- Connectivité des éléments ? \n");
3484 fprintf(stdout,
" 1. Nodale : taper 1 \n");
3485 fprintf(stdout,
" 2. Descendante : taper 2 \n");
3488 fprintf(stdout,
" Reponse : ");
3489 if (!scanf(
"%d",&reponse)) fgets(_temp, 256, stdin) ;
3490 }
while (reponse != 1 && reponse != 2);
3506 char *
const maillage_description,
3508 char *
const dtunit,
3509 char *
const nomcoo,
3510 char *
const unicoo,
3517 fprintf(stdout,
"\n(**********************************************************)\n");
3518 fprintf(stdout,
"(* INFORMATIONS GENERALES SUR LE MAILLAGE DE CALCUL N°%2.2d: *)\n",numero);
3519 fprintf(stdout,
"(**********************************************************)\n\n");
3522 ret =
MEDmeshInfo(fid, numero,nommaa,edim,mdim,type_maillage,maillage_description,
3523 dtunit,&sortingtype,nstep,rep,nomcoo,unicoo);
3524 EXIT_IF(ret < 0,
"Lecture des informations sur le maillage",NULL);
3527 fprintf(stdout,
"- Nom du maillage : <<%s>>\n",nommaa);
3528 fprintf(stdout,
"- Dimension du maillage : "IFORMAT"\n",*mdim);
3530 fprintf(stdout,
"- La dimension de l'espace est "IFORMAT" \n",*edim);
3532 fprintf(stdout,
"- Type du maillage : MED_NON_STRUCTURE \n");
3534 fprintf(stdout,
"- Type du maillage : MED_STRUCTURE \n");
3535 fprintf(stdout,
"- Description associee au maillage : %s\n",
3536 maillage_description);
3539 fprintf(stdout,
"- Nombre d'étapes de calcul associées au maillage : "IFORMAT"\n",
3542 fprintf(stdout,
"- Unité des dates d'étapes de calcul associées au maillage : %s\n",
3548 fprintf(stdout,
"- Nom universel du maillage : %s \n",nom_universel);
3567 int i=0,numero=0,firstmesh=0,lastmesh=0,meshit=0;
3570 int lecture_en_tete_seulement = 0;
3571 med_int mdim=0,nmaa=0,nmaasup=0;
3586 char *
filename=NULL,*typ_con_param=NULL,*mode_coo_param=NULL;
3587 size_t _bannerlen=0;
3589 char * _bannerstr=NULL;
3597 char *_geotypename_elst = NULL;
3607 if (argc > 2 && strcmp(argv[1],
"--structure") == 0) {
3613 if ( (argc != 2) && (argc != 5) ) {
3615 fprintf(stderr,
"Utilisation mdump [--structure] monfichier.med [ NODALE|DESCENDANTE "
3616 "NO_INTERLACE|FULL_INTERLACE|LECTURE_EN_TETE_SEULEMENT N°MAILLAGE|0 pour tous ] \n");
3618 "\t--structure : Lis l'ensemble des données sans afficher les données volumineuses\n"
3619 "\tNODALE : Scrute la connectivité nodale des maillages\n"
3620 "\tDESCENDANTE : Scrute la connectivité descendante des maillages\n"
3621 "\tFULL_INTERLACE : Affiche les connectivités en mode entrelacé x1y1x2y2\n"
3622 "\tNO_INTERLACE : Affiche les connectivités en mode non entrelacé x1x2y1y2\n"
3623 "\tLECTURE_EN_TETE_SEULEMENT : Affiche uniquement les entêtes, désactive la lecture et l'affichage des données volumineuses\n"
3624 "\tN°MAILLAGE == i : Affiche le maillage n°i et ses champs associés\n"
3625 "\tN°MAILLAGE == 0 : Affiche l'ensemble des maillages et leurs champs associés\n"
3626 "\tN°MAILLAGE == -1 : Affiche l'ensemble des champs qu'ils soient associés ou non à un maillage local\n");
3628 EXIT_IF( (argc != 2) && (argc != 5),
"nombre de parametres incorrect\n",NULL);
3643 fprintf(stdout,
"\n >>>>>> DUMP DU FICHIER %s >>>>>>\n",
filename);
3652 typ_con_param=argv[2 + decalage];
3654 if (! strcmp(typ_con_param,
"NODALE")) typ_con =
MED_NODAL;
3655 if (! strcmp(typ_con_param,
"DESCENDANTE")) typ_con =
MED_DESCENDING;
3657 mode_coo_param=argv[3 + decalage];
3664 "Le paramètre d'entrelacement doit être soit "
3665 "NO_INTERLACE|FULL_INTERLACE|LECTURE_EN_TETE_SEULEMENT",NULL);
3689 fprintf(stdout,
"- Il y a "IFORMAT" maillage(s) de type local dans ce fichier \n",nmaa);
3690 fprintf(stdout,
" Lequel voulez-vous lire (0 pour tous|1|2|3|...|n) ?\n");
3692 fprintf(stdout,
" Reponse : ");
3693 if (!scanf(
"%d",&numero)) fgets(_temp, 256, stdin) ;
3694 }
while ( (numero > nmaa) || (numero < -1) );
3696 fprintf(stdout,
"- Il n'y a pas de maillage local dans ce fichier \n");
3700 numero = atoi(argv[4 + decalage]);
3701 EXIT_IF(numero > nmaa || numero < -1,
"ce numero de maillage n'existe pas", NULL);
3711 fprintf(stdout,
"\n(*****************************************************)\n");
3712 fprintf(stdout,
"(* INFORMATIONS GENERALES SUR LES MAILLAGES SUPPORT: *)\n");
3713 fprintf(stdout,
"(*****************************************************)\n");
3715 for (meshit=1;meshit <= nmaasup;++meshit) {
3719 maillage_description, &rep, nomcoo, unicoo);
3720 fprintf(stdout,
"\n(*******************************************)\n");
3721 fprintf(stdout,
"(******** Maillage support n°%2.2d/%2.2"MED_IFORMAT" : *******)\n",meshit,nmaasup);
3722 fprintf(stdout,
"(*******************************************)\n");
3724 fprintf(stdout,
"- Nom du maillage support : <<%s>>\n",nommaa);
3725 fprintf(stdout,
"- Dimension du maillage : "IFORMAT"\n",mdim);
3727 fprintf(stdout,
"- La dimension de l'espace est "IFORMAT" \n",edim);
3730 nomcoo,unicoo,&rep, &_nmodels, &_geotype_elst,&_geotypename_elst,
3774 firstmesh=numero;lastmesh=numero;
3775 }
else if (numero == 0) {
3776 firstmesh=1;lastmesh=nmaa;
3778 firstmesh = nmaa +1;
3781 for (meshit=firstmesh;meshit<=lastmesh;++meshit) {
3784 maillage_description,&nstep,dtunit,nomcoo,unicoo,&rep);
3788 fprintf(stderr,
"Warning : Ce maillage n'a aucune étape de calcul, ceci est anormal..."
3789 "\n\t Recherche des champs résultats associés à ce maillage.\n");
3792 for (; csit <= nstep; ++csit) {
3797 EXIT_IF(ret < 0,
"lors de l'appel à MEDmeshComputationStepInfo",NULL);
3805 _bannerstr =
"(* MAILLAGE DE CALCUL |%s| n°%2.2d A L'ETAPE DE CALCUL (n°dt,n°it)="
3807 snprintf(_temp,
MAXBANNERLEN+1,_bannerstr,nommaa,meshit,numdt,numit,0,
"");
3808 _bannerlen =strlen(_temp);
3809 fprintf(stdout,
"\n(");
3810 for (i=0;i< _bannerlen-6; i++) fprintf(stdout,
"*");
3811 fprintf(stdout,
")\n%s(",_temp);
3812 for (i=0;i< _bannerlen-6; i++) fprintf(stdout,
"*");
3813 fprintf(stdout,
")\n");
3823 &_nmodels,&_geotype_elst,&_geotypename_elst,
3824 lecture_en_tete_seulement);
3827 nomcoo,unicoo,lecture_en_tete_seulement);
3835 _nmodels,_geotype_elst,_geotypename_elst,
3836 lecture_en_tete_seulement);
3838 free(_geotype_elst);
3839 free(_geotypename_elst);
3850 _nmodels,_geotype_elst,_geotypename_elst,
3851 lecture_en_tete_seulement);
3853 free(_geotype_elst);
3854 free(_geotypename_elst);
3860 for (i=1;i <
FIDS.
n ; ++i)
3862 printf(
"Erreur de démontage du fichier n°%d\n",i);
3867 EXIT_IF(ret < 0,
"lors de la fermeture du fichier",argv[1 + decalage]);
3869 fprintf(stdout,
"\n >>>>>> FIN DU DUMP DU FICHIER %s >>>>>>\n",argv[1 + decalage]);
3871 return EXIT_SUCCESS;
#define MED_N_CELL_GEO_FIXED_CON
MEDC_EXPORT const char *const MEDgetEntityTypeName(med_entity_type entitytype)
#define MED_ALL_CONSTITUENT
#define MED_N_FACE_GEO_FIXED_CON
#define MED_N_NODE_FIXED_GEO
#define MED_N_ENTITY_TYPES
#define MED_N_FACE_FIXED_GEO
#define MED_N_EDGE_FIXED_GEO
#define MED_N_CELL_FIXED_GEO
#define MED_N_EDGE_GEO_FIXED_CON
@ MED_UNDEF_CONNECTIVITY_MODE
#define EXIT_IF(expression, message, arg)
#define ISCRUTE_int(entier)
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.
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.
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...
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 é...
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...
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....
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....
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.
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.
MEDC_EXPORT med_err MEDfieldGeometryType(const med_idt fid, const char *const fieldname, const med_int numdt, const med_int numit, const med_entity_type entitytype, med_geometry_type *const geometrytypes, med_int *const usedbyncs)
Cette fonction retourne la liste des types géométrique présents dans un champ (med_geometry_type) pou...
MEDC_EXPORT med_int MEDnField(const med_idt fid)
Cette fonction permet de lire le nombre de champs dans un fichier.
MEDC_EXPORT med_err MEDfieldEntityType(const med_idt fid, const char *const fieldname, const med_int numdt, const med_int numit, med_entity_type *const entitytypes, med_int *const usedbyncs)
Cette fonction retourne la liste des types d'entité présents dans un champ (med_entity_type).
MEDC_EXPORT med_int MEDfieldnEntityType(const med_idt fid, const char *const fieldname, const med_int numdt, const med_int numit)
Cette fonction indique le nombre de types d'entité présents dans un champ (med_entity_type).
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,...
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,...
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 ...
MEDC_EXPORT med_int MEDfieldnComponent(const med_idt fid, const int ind)
Cette fonction lit le nombre de composantes d'un champ.
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...
MEDC_EXPORT med_int MEDfieldnGeometryType(const med_idt fid, const char *const fieldname, const med_int numdt, const med_int numit, const med_entity_type entitytype)
Cette fonction indique le nombre de types géométriques (med_geometry_type) présents dans le champ fie...
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 .
MEDC_EXPORT med_err MEDfileClose(med_idt fid)
Fermeture d'un fichier MED.
MEDC_EXPORT med_idt MEDfileObjectsMount(const med_idt fid, const char *const filename, const med_class medclass)
Cette routine permet de monter dans le fichier courant un type de données (exemples les maillages,...
MEDC_EXPORT med_err MEDfileObjectsUnmount(const med_idt fid, const med_idt mid, const med_class medclass)
Une fois le démontage effectué, les données précédemment montées ne sont plus accessibles.
MEDC_EXPORT med_idt MEDfileOpen(const char *const filename, const med_access_mode accessmode)
Ouverture d'un fichier MED.
MEDC_EXPORT med_err MEDfileCommentRd(const med_idt fid, char *const comment)
Lecture d'un descripteur dans un fichier MED.
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.
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.
MEDC_EXPORT med_int MEDnInterp(const med_idt fid)
Cette routine renvoie le nombre d'interpolations disponibles dans le fichier.
MEDC_EXPORT med_err MEDinterpInfo(const med_idt fid, const int interpit, char *const interpname, med_geometry_type *const geotype, med_bool *const cellnode, med_int *const nbasisfunc, med_int *const nvariable, med_int *const maxdegree, med_int *const nmaxcoef)
Cette fonction informe des caractéristiques de la fonction d'interpolation n° interpit.
MEDC_EXPORT med_err MEDinterpBaseFunctionRd(const med_idt fid, const char *const interpname, const int basisfuncit, med_int *const ncoef, med_int *const power, med_float *const coefficient)
Cette routine permet la lecture d'une fonction de base/forme de l'interpolation interpname.
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.
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.
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.
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.
MEDC_EXPORT med_int MEDnLink(const med_idt fid)
Cette routine permet la lecture du nombre de lien dans un fichier MED.
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...
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...
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...
MEDC_EXPORT med_int MEDnMesh(const med_idt fid)
Cette routine permet de lire le nombre de maillages dans un fichier.
MEDC_EXPORT med_err MEDmeshEntityInfo(const med_idt fid, const char *const meshname, const med_int numdt, const med_int numit, const med_entity_type entitype, const int geotypeit, char *const geotypename, med_geometry_type *const geotype)
Cette routine indique de façon itérative les types géométriques disponibles dans un maillage.
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,...
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.
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.
MEDC_EXPORT med_err MEDmeshPolygon2Rd(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 polytype, const med_connectivity_mode cmode, med_int *const polyindex, med_int *const connectivity)
Cette routine permet la lecture des connectivités de polygones.
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.
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.
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...
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.
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é...
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.
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.
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...
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.
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...
MEDC_EXPORT med_err MEDmeshGeotypeParameter(const med_idt fid, const med_geometry_type geotype, med_int *const geodim, med_int *const nnodes)
Cette routine renvoie les caractéristiques d'un type géométrique de maille.
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).
MEDC_EXPORT med_err MEDmeshGeotypeName(const med_idt fid, const med_geometry_type geotype, char *const geotypename)
Cette routine renvoie le nom associé à un type géométrique.
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.
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...
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.
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.
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.
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.
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.
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.
MEDC_EXPORT med_int MEDnProfile(const med_idt fid)
Cette routine permet de lire le nombre de profils dans un fichier MED.
MEDC_EXPORT med_int MEDnStructElement(const med_idt fid)
Cette routine renvoie le nombre de modèles d'éléments de structure.
MEDC_EXPORT med_err MEDstructElementVarAttInfo(const med_idt fid, const char *const modelname, const int attit, char *const varattname, med_attribute_type *const varatttype, med_int *const ncomponent)
Cette routine décrit les caractéristiques d'un attribut variable de modèle d'élément de structure par...
MEDC_EXPORT med_err MEDstructElementInfo(const med_idt fid, const int mit, char *const modelname, med_geometry_type *const mgeotype, med_int *const modeldim, char *const supportmeshname, med_entity_type *const sentitytype, med_int *const snnode, med_int *const sncell, med_geometry_type *const sgeotype, med_int *const nconstantattribute, med_bool *const anyprofile, med_int *const nvariableattribute)
Cette routine décrit les caractéristiques d'un modèle d'élément de structure par itération.
MEDC_EXPORT int MEDstructElementAttSizeof(const med_attribute_type atttype)
Cette routine renvoie la taille en octets du type élémentaire atttype.
MEDC_EXPORT med_err MEDstructElementConstAttRd(const med_idt fid, const char *const modelname, const char *const constattname, void *const value)
Cette routine lit la valeur d'un attribut caractéristique constant d'un modèle d'éléments de structur...
MEDC_EXPORT med_err MEDmeshStructElementVarAttRd(const med_idt fid, const char *const meshname, const med_int numdt, const med_int numit, const med_geometry_type mgeotype, const char *const varattname, void *const value)
Cette routine lit les valeurs d'un attribut caractéristique variable sur les éléments de structure d'...
MEDC_EXPORT med_err MEDstructElementConstAttInfo(const med_idt fid, const char *const modelname, const int attit, char *const constattname, med_attribute_type *const constatttype, med_int *const ncomponent, med_entity_type *const sentitytype, char *const profilename, med_int *const profilesize)
Cette routine décrit les caractéristiques d'un attribut constant de modèle d'élément de structure par...
MEDC_EXPORT med_err MEDstructElementInfoByName(const med_idt fid, const char *const modelname, med_geometry_type *const mgeotype, med_int *const modeldim, char *const supportmeshname, med_entity_type *const sentitytype, med_int *const snnode, med_int *const sncell, med_geometry_type *const sgeotype, med_int *const nconstantatribute, med_bool *const anyprofile, med_int *const nvariableattribute)
Cette routine décrit les caractéristiques d'un modèle d'élément de structure à partir de son nom.
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.
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...
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.
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...
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...
MEDC_EXPORT med_int MEDnSupportMesh(const med_idt fid)
Cette routine permet de lire le nombre de maillages support dans un fichier.
MEDC_EXPORT med_err MEDsupportMeshInfo(const med_idt fid, const int meshit, char *const supportmeshname, med_int *const spacedim, med_int *const meshdim, char *const description, med_axis_type *const axistype, char *const axisname, char *const axisunit)
Cette routine permet de lire les informations relatives à un maillage support dans un fichier.
const char *const MED23FIELD_GET_ENTITY_TYPENAME[MED_N_ENTITY_TYPES+2]
void affi(const void *pva)
const char *const * nomare
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)
const char *const * nomfac
const char *const MED23FIELD_GET_CELL_GEOMETRY_TYPENAME[MED_N_CELL_FIXED_GEO+2]
const med_geometry_type *const typmai
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)
med_geometry_type MED23MESH_GET_FACE_GEOMETRY_TYPE[MED_N_FACE_FIXED_GEO+2]
void lecture_joint_maillage(med_idt fid, const char *const nommaa, med_int njnt)
med_entity_type MED23MESH_GET_ENTITY_TYPE[MED_N_ENTITY_TYPES+2]
med_int lecture_nombre_faces_polygones(const med_idt fid, const char *const nommaa, const med_int numdt, const med_int numit)
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)
med_geometry_type MED23FIELD_GET_NODE_GEOMETRY_TYPE[MED_N_NODE_FIXED_GEO+2]
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)
void lecture_fonctions_interpolation(med_idt fid, int lecture_en_tete_seulement)
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 med_int nmodels, const med_geometry_type *geotype_elst, const char *geotypename_elst, const int lecture_en_tete_seulement)
const char * MED23MESH_GET_EDGE_GEOMETRY_TYPENAME[MED_N_EDGE_FIXED_GEO+2]
#define MDUMP_MAX_FILE_OPEN
med_int lecture_nombre_equivalence(med_idt fid, const char *const nommaa)
int main(int argc, char **argv)
med_geometry_type MED23FIELD_GET_CELL_GEOMETRY_TYPE[MED_N_CELL_FIXED_GEO+2]
med_entity_type MED23FIELD_GET_ENTITY_TYPE[MED_N_ENTITY_TYPES+2]
void affd(const void *pva)
const med_geometry_type *const typfac
med_geometry_type MED23FIELD_GET_EDGE_GEOMETRY_TYPE[MED_N_EDGE_FIXED_GEO+2]
void lecture_mailles_elstruct(const med_idt fid, const char *const nommaa, const med_int numdt, const med_int numit, const med_int nmodels, const med_geometry_type *const geotype, const char *const geotypename, const med_int *const nmailles, const med_switch_mode mode_coo)
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)
med_geometry_type MED23MESH_GET_NODE_GEOMETRY_TYPE[MED_N_NODE_FIXED_GEO+2]
const med_geometry_type *const typare
void lecture_mailles_polygones(const med_idt fid, const char *const nommaa, const med_int numdt, const med_int numit, const med_geometry_type polytype, const med_int nmpolygones, const med_switch_mode mode_coo, const med_connectivity_mode typ_con)
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, med_int *nmodels, med_geometry_type **geotype_elst, char **geotypename_elst, const int lecture_en_tete_seulement)
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)
void lecture_modeles_elstruct(med_idt fid, int lecture_en_tete_seulement)
#define MED_LECTURE_ENTETE_SEULEMENT
const char *const MED23MESH_GET_ENTITY_TYPENAME[MED_N_ENTITY_TYPES+2]
const char * MED23MESH_GET_NODE_GEOMETRY_TYPENAME[MED_N_NODE_FIXED_GEO+2]
void affs(const void *pva)
void lecture_parametres_scalaires(med_idt fid, int lecture_en_tete_seulement)
void parametrage(med_switch_mode *mode_coo, med_connectivity_mode *typ_con)
#define MDUMP_MAX_FILE_OPEN_INIT
med_geometry_type MED23FIELD_GET_FACE_GEOMETRY_TYPE[MED_N_FACE_FIXED_GEO+2]
med_int lecture_nombre_joint(med_idt fid, const char *const nommaa)
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)
_myfuncptr MEDstructPrintFunction(med_attribute_type atttype)
const char *const MED23FIELD_GET_FACE_GEOMETRY_TYPENAME[MED_N_FACE_FIXED_GEO+2]
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)
void lecture_equivalence_maillage(med_idt fid, const char *const nommaa, med_int nequ)
const char *const MED23MESH_GET_CELL_GEOMETRY_TYPENAME[MED_N_CELL_FIXED_GEO+2]
void lecture_profils(med_idt fid, int lecture_en_tete_seulement)
med_int lecture_nombre_famille(med_idt fid, const char *const nommaa)
med_geometry_type MED23MESH_GET_EDGE_GEOMETRY_TYPE[MED_N_EDGE_FIXED_GEO+2]
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)
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)
void lecture_localisation(med_idt fid, const med_switch_mode mode_coo, int lecture_en_tete_seulement)
med_idt ouverture_fichier_MED(char *fichier)
med_int lecture_nombre_et_type_mailles_elstruct(const med_idt fid, const char *const nommaa, const med_int numdt, const med_int numit, const int indice, med_geometry_type *geotype, char *geotypename)
#define MED_LECTURE_MAILLAGE_SUPPORT_UNIQUEMENT
med_err getFieldsOn(const med_idt fid, const char *const maillage, const med_int mnumdt, const med_int mnumit, const med_int nmodels, const med_geometry_type *const geotype_elst, const char *const geotypename_elst, const char *const nomcha, const char *const dtunit, const med_field_type typcha, const med_int ncomp, const char *const comp, const char *const unit, const med_entity_type entite, const med_switch_mode stockage, const med_int ncstp)
void lecture_liens(med_idt fid, med_bool montage, int lecture_en_tete_seulement)
const char *const * nommai
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)
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)
med_int lecture_nombre_noeuds_maillage_non_structure(const med_idt fid, const char *nommaa, const med_int numdt, const med_int numit)
med_int lecture_nombre_mailles_polygones(const med_idt fid, const char *const nommaa, const med_int numdt, const med_int numit, const med_geometry_type polytype, const med_connectivity_mode typ_con)
const char *const MED23MESH_GET_FACE_GEOMETRY_TYPENAME[MED_N_FACE_FIXED_GEO+2]
void(* _myfuncptr)(const void *)
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)
med_geometry_type MED23MESH_GET_CELL_GEOMETRY_TYPE[MED_N_CELL_FIXED_GEO+2]
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)
void lecture_en_tete(med_idt fid, char *fichier)
void lecture_famille_maillage(med_idt fid, const char *const nommaa, med_int nfam)
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)
const char * MED23FIELD_GET_EDGE_GEOMETRY_TYPENAME[MED_N_EDGE_FIXED_GEO+2]
const char * MED23FIELD_GET_NODE_GEOMETRY_TYPENAME[MED_N_NODE_FIXED_GEO+2]
#define MED_ERR_GEOMETRY_MSG
#define MED_ERR_RANGE_MSG
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)
MEDC_EXPORT med_err _MEDgetInternalGeometryTypeName(const med_idt fid, char *const geotypename, med_geometry_type geotype)
med_idt array[MDUMP_MAX_FILE_OPEN]