83 #define snprintf _snprintf
126 #define MED_LECTURE_MAILLAGE_SUPPORT_UNIQUEMENT 2
127 #define MED_LECTURE_ENTETE_SEULEMENT 1
129 #define USER_MODE MED_COMPACT_STMODE
131 #define xstr(s) str(s)
134 #define MIN(a,b) ((a) < (b) ? (a) : (b))
135 #define MAX(a,b) ((a) > (b) ? (a) : (b))
137 #define MAXBANNERLEN 255
141 const double *pa = pva;
155 const char *pa = pva;
173 EXIT_IF(-1,
"lors de la lecture du type d'attribut à afficher.",NULL);
184 EXIT_IF(nfam < 0,
"lors de la lecture du nombre de familles",NULL);
185 fprintf(stdout,
"- Nombre de familles : "IFORMAT" \n",nfam);
194 char *attdes=NULL,*gro=NULL;
195 med_int *attval=NULL,*attide=NULL;
204 fprintf(stdout,
"\n(**************************)\n");
205 fprintf(stdout,
"(* FAMILLES DU MAILLAGE : *)\n");
206 fprintf(stdout,
"(**************************)\n");
209 for (i=0;i<nfam;i++) {
213 EXIT_IF(ngro < 0,
"lors de la lecture du nombre de groupe d'une famille",
218 EXIT_IF(natt < 0,
"lors de la lecture du nombre d'attributs d'une famille",
228 EXIT_IF(attide == NULL,NULL,NULL);
230 EXIT_IF(attval == NULL,NULL,NULL);
232 EXIT_IF(attdes == NULL,NULL,NULL);
234 EXIT_IF(gro == NULL,NULL,NULL);
237 EXIT_IF(ret < 0,
"lors de la lecture des informations d'une famille",
244 fprintf(stdout,
" - Famille de nom %s et de numero "IFORMAT
" : \n",nomfam,numfam);
245 fprintf(stdout,
" - Attributs : \n");
246 for (j=0;j<natt;j++) {
249 fprintf(stdout,
" ide = "IFORMAT
" - val = "IFORMAT
" - des = %s\n",*(attide+j),
255 if (attide) {free(attide);attide=NULL;}
256 if (attval) {free(attval);attval=NULL;}
257 if (attdes) {free(attdes);attdes=NULL;}
260 fprintf(stdout,
" - Groupes :\n");
261 for (j=0;j<ngro;j++) {
264 fprintf(stdout,
" gro = %s\n",str2);
269 if (gro) {free(gro);gro=NULL;}
272 if (famille_0 != 1) {
273 MESSAGE(
"Erreur : La famille FAMILLE_ZERO n'a pas été trouvée, elle est obligatoire. ");
282 EXIT_IF(nequ < 0,
"lors de la lecture du nombre d'equivalences",NULL);
283 fprintf(stdout,
"- Nombre d'equivalences : "IFORMAT" \n",nequ);
303 fprintf(stdout,
"\n(******************************)\n");
304 fprintf(stdout,
"(* EQUIVALENCES DU MAILLAGE : *)\n");
305 fprintf(stdout,
"(******************************)\n");
309 for (i = 0;i<nequ;i++) {
313 EXIT_IF(ret < 0,
"lors de la lecture des informations sur une equivalence",
317 fprintf(stdout,
"- Equivalence numero : "IFORMAT" ",i+1);
318 fprintf(stdout,
"\n - Nom de l'equivalence: %s \n",equ);
319 fprintf(stdout,
"\n - Description de l'equivalence : %s \n",des);
321 fprintf(stdout,
"\n - L'equivalence est définie sur "IFORMAT" étapes de calcul\n",nstep);
324 for (_cstpit=1; _cstpit <= nstep; ++_cstpit) {
327 & _numdt, &_numit,&nocstpncor);
329 "lors de la lecture des valeurs de séquence de calcul d'une equivalence",
333 fprintf(stdout,
"\n - Séquence de calcul définie sur (numdt,numit) ("IFORMAT","IFORMAT") :\n",_numdt,_numit);
340 "lors de la lecture du nombre de correspondances d'une equivalence",
342 fprintf(stdout,
"\n - Il y a "IFORMAT
" correspondances sur les noeuds \n",ncor);
348 EXIT_IF(cor == NULL,NULL,NULL);
351 EXIT_IF(ret < 0,
"lors de la lecture du tableau des correspondances",
355 fprintf(stdout,
"\n - Correspondance "IFORMAT
" : "IFORMAT
" et "IFORMAT
" \n",j+1,*(cor+2*j),
366 "lors de la lecture du nombre de correspondances dans une equivalence",
368 fprintf(stdout,
"\n - Il y a "IFORMAT
" correspondances sur les mailles %s \n",ncor,
375 EXIT_IF(cor == NULL,NULL,NULL);
378 EXIT_IF(ret < 0,
"lors de la lecture du tableau des equivalences",
383 fprintf(stdout,
"\n - Correspondance "IFORMAT
" : "IFORMAT
" et "IFORMAT
" \n",k+1,
384 *(cor+2*k),*(cor+2*k+1));
398 "lors de la lecture du nombre de correspondances dans une equivalence",
400 fprintf(stdout,
"\n - Il y a "IFORMAT
" correspondances sur les faces %s\n",ncor,
407 EXIT_IF(cor == NULL,NULL,NULL);
410 EXIT_IF(ret < 0,
"lors de la lecture du tableau des equivalences",
415 fprintf(stdout,
"\n - Correspondance "IFORMAT
" : "IFORMAT
" et "IFORMAT
" \n",k+1,*(cor+2*k),
428 EXIT_IF(ret < 0,
"lors de la lecture du nombre de correspondances",
430 fprintf(stdout,
"\n - Il y a "IFORMAT
" correspondances sur les aretes %s \n",
437 EXIT_IF(cor == NULL,NULL,NULL);
440 EXIT_IF(ret < 0,
"lors de la lecture du tableau des equivalences",
445 fprintf(stdout,
"\n Correspondance "IFORMAT
" : "IFORMAT
" et "IFORMAT
" \n",k+1,*(cor+2*k),
462 EXIT_IF(njnt < 0,
"lors de la lecture du nombre de joints",NULL);
463 fprintf(stdout,
"- Nombre de joints : "IFORMAT" \n",njnt);
474 med_int typ_ent_local,typ_geo_local,typ_ent_distant,typ_geo_distant;
484 med_int njstep=0,ncor=0,nodtitncor=0;
489 fprintf(stdout,
"\n(******************************)\n");
490 fprintf(stdout,
"(* JOINTS DU MAILLAGE : *)\n");
491 fprintf(stdout,
"(******************************)\n");
495 for (i = 0;i<njnt;i++) {
496 fprintf(stdout,
"- Joint numero : "IFORMAT" ",i+1);
500 EXIT_IF(ret < 0,
"lors de la lecture des informations sur un joint",
503 fprintf(stdout,
"\n - Nom du joint: %s \n",jn);
504 fprintf(stdout,
"\n - Description du joint : %s ",des);
505 fprintf(stdout,
"\n - Domaine en regard : "IFORMAT" ",ndom);
506 fprintf(stdout,
"\n - Maillage distant : %s ",maa_dist);
508 printf(
"Nombre d'étapes de calcul : "IFORMAT" \n",njstep);
509 printf(
"Nombre de correspondance pour (NO_DT,NO_IT) : "IFORMAT" \n",nodtitncor);
512 for (csit=1; csit <= njstep; ++csit) {
515 EXIT_IF(ret < 0,
"Erreur a la lecture des valeurs (numdt,numit) dans les joints",
518 printf(
"Séquence de calcul (numdt,numit) : ("IFORMAT","IFORMAT")\n",_numdt,_numit);
521 while ( corit <= ncor ) {
527 EXIT_IF(ret < 0,
"Erreur a la lecture des infos sur le nombre d'entite en regard",
530 if (typ_ent_local ==
MED_NODE) strcpy(nom_geo_ent_local,
"MED_NOEUD");
532 EXIT_IF(ret < 0,
"Erreur à l'appel de _MEDgetInternalGeometryTypeName", NULL);
533 if (typ_ent_distant ==
MED_NODE) strcpy(nom_geo_ent_distant,
"MED_NOEUD");
535 EXIT_IF(ret < 0,
"Erreur à l'appel de _MEDgetInternalGeometryTypeName", NULL);
536 fprintf(stdout,
"\n\t\t- nb de couples d'entites en regard (local,distant)=(%s,%s) : "IFORMAT" \n",
537 nom_geo_ent_local,nom_geo_ent_distant, nent);
542 typ_ent_local,typ_geo_local,typ_ent_distant,typ_geo_distant,
544 fprintf(stdout,
"\n\t\t- Erreur a la lecture des correspondances sur (%s,%s,%s,%s)",
551 *(cortab+2*k),*(cortab+2*k+1));
578 EXIT_IF(nnoe < 0,
"lors de la lecture du nombre de noeuds",NULL);
579 fprintf(stdout,
"- Nombre de noeuds : "IFORMAT" \n",nnoe);
586 const char *
const nommaa,
593 const char *
const nomcoo,
594 const char *
const unicoo,
611 EXIT_IF(coo == NULL,NULL,NULL);
615 EXIT_IF(numnoe == NULL,NULL,NULL);
617 EXIT_IF(nufano == NULL,NULL,NULL);
621 EXIT_IF(nomnoe == NULL,NULL,NULL);
629 &inonoe,nomnoe,&inunoe,numnoe,&ifano,nufano);
632 EXIT_IF(ret < 0,
"lors de la lecture des noeuds du maillage \n",NULL);
636 fprintf(stdout,
"\n(************************)\n");
637 fprintf(stdout,
"(* NOEUDS DU MAILLAGE : *)\n");
638 fprintf(stdout,
"(************************)\n\n");
641 fprintf(stdout,
"- Type de repere des coordonnees : %d \n",*rep);
642 fprintf(stdout,
"- Nom des coordonnees : \n");
643 for (i=0;i<edim;i++) {
646 fprintf(stdout,
" %s ",str);
648 fprintf(stdout,
"\n- Unites des coordonnees : \n");
649 for (i=0;i<edim;i++) {
652 fprintf(stdout,
" %s ",str);
654 fprintf(stdout,
"\n- Coordonnees des noeuds : ");
655 for (i=0;i<nnoe*edim;i++) {
657 fprintf(stdout,
"\n [ %5"MED_IFORMAT" ] : ", (i/edim + 1) );
659 fprintf(stdout,
"\n\n ");
660 fprintf(stdout,
" %-+9.6f ",*(coo+i));
664 fprintf(stdout,
"\n- Noms des noeuds : \n");
665 for (i=0;i<nnoe;i++) {
668 fprintf(stdout,
" %s ",str);
672 fprintf(stdout,
"\n- Numeros des noeuds : \n");
674 fprintf(stdout,
" "IFORMAT" ",*(numnoe+i));
677 fprintf(stdout,
"\n- Numeros des familles des noeuds : \n");
678 for (i=0;i<nnoe;i++) {
680 fprintf(stdout,
" "IFORMAT" ",*(nufano+i));
682 fprintf(stdout,
" %d ",0);
684 fprintf(stdout,
"\n");
699 const char *
const nommaa,
712 EXIT_IF(nmailles < 0,
" lors de la lecture du nombre de mailles",NULL);
717 fprintf (stdout,
"- Nombre de mailles de type %s : "IFORMAT" \n",
nommai[indice],
724 const char *
const nommaa,
737 indice+1,geotypename,geotype );
739 "Erreur à la demande d'informations pour le type d'entités MED_STRUCT_ELEMENT",NULL);
745 EXIT_IF(_nmailles < 0,
" lors de la lecture du nombre de mailles",NULL);
748 fprintf (stdout,
"- Nombre de mailles de type %s : "IFORMAT" \n",geotypename, _nmailles);
754 const char *
const nommaa,
759 const char*
const geotypename,
760 const med_int *
const nmailles,
789 void *_attvalue=NULL;
790 void (*_printf)(
const void*);
794 for (i=0; i<nmodels; i++ ) {
797 &_geotype,&_elementdim,
798 _supportmeshname,&_entitytype,&_nnode,&_ncell,
799 &_geocelltype,&_nconstantatribute,&_anyprofile,&_nvariableattribute);
802 taille=_ncell*_geocelltype%100;
812 connectivite = (
med_int*) calloc(taille*nmailles[i],
sizeof(
med_int));
813 EXIT_IF(connectivite == NULL,NULL,NULL);
814 nomele = (
char*) malloc(
sizeof(
char)*
MED_SNAME_SIZE*nmailles[i]+1);
815 EXIT_IF(nomele == NULL,NULL,NULL);
817 EXIT_IF(numele == NULL,NULL,NULL);
819 EXIT_IF(nufael == NULL,NULL,NULL);
824 &inoele,nomele,&inuele,numele,&inufael,nufael );
826 EXIT_IF(_ret < 0,
"lors de la lecture des mailles",NULL);
830 fprintf(stdout,
"\n(***************************************)\n");
831 fprintf(stdout,
"(* ELEMENTS DE STRUCTURE DU MAILLAGE : *)\n");
832 fprintf(stdout,
"(***************************************)\n");
837 fprintf(stdout,
"\n- Mailles de type %s : ", &geotypename[i*(
MED_NAME_SIZE+1)]);
838 if (strcmp(&geotypename[i*(
MED_NAME_SIZE+1)],
"MED_PARTICLE") ) {
839 fprintf(stdout,
"\n - Connectivité : ");
840 for (j=0;j<nmailles[i]*taille;j++) {
842 fprintf(stdout,
"\n [ %5"MED_IFORMAT" ] : ", (j/taille +1) );
844 fprintf(stdout,
"\n");
845 fprintf(stdout,
" %9"MED_IFORMAT" ",*(connectivite+j));
850 fprintf(stdout,
"\n - Noms : \n");
851 for (j=0;j<nmailles[i];j++) {
854 fprintf(stdout,
" %s ",str);
858 fprintf(stdout,
"\n - Numeros :\n");
859 for (j=0;j<nmailles[i];j++)
860 fprintf(stdout,
" "IFORMAT" ",*(numele+j));
862 fprintf(stdout,
"\n - Numéros de familles : \n");
863 for (j=0;j<nmailles[i];j++)
865 fprintf(stdout,
" "IFORMAT" ",*(nufael+j));
867 fprintf(stdout,
" %d ",0);
868 fprintf(stdout,
"\n");
873 for (k=0; k<_nvariableattribute; k++) {
877 _attname, &_atttype, &_nattcomp);
878 EXIT_IF(_ret < 0,
"lors de la lecture des caractéristiques de attributs variables",NULL);
882 EXIT_IF(_atttype ==
MED_ATT_UNDEF,
"à la lecture du type (valeur : MED_ATT_UNDEF) de l'attribut variable ",_attname);
885 _attvaluesize = nmailles[i]*_nattcomp*_atttypesize;
887 _attvalue = (
void *) malloc( _attvaluesize*
sizeof(
char));
892 *(geotype+i), _attname, _attvalue );
893 if (_ret < 0 ) free(_attvalue);
894 EXIT_IF(_ret < 0,
"lors de la lecture des attributs variables",NULL);
899 fprintf(stdout,
"\n - Valeurs de l'attribut |%s| pour le type géométrique |%s| : \n",_attname,
901 for (j=0;j<nmailles[i]*_nattcomp;j++) {
902 if ( ( _nattcomp > 1 ) && !(j % _nattcomp) )
903 fprintf(stdout,
"\n [ %5"MED_IFORMAT" ] : ", (j/_nattcomp +1) );
904 _printf( (
void *)( (
char *)(_attvalue) + j*_atttypesize) );
927 const med_int *
const nmailles,
947 if (nmailles[i] > 0) {
950 EXIT_IF(ret < 0,
"lors de la lecture des caractéristiques des mailles",NULL);
966 connectivite = (
med_int*) malloc(
sizeof(
med_int)*taille*nmailles[i]);
967 EXIT_IF(connectivite == NULL,NULL,NULL);
968 nomele = (
char*) malloc(
sizeof(
char)*
MED_SNAME_SIZE*nmailles[i]+1);
969 EXIT_IF(nomele == NULL,NULL,NULL);
971 EXIT_IF(numele == NULL,NULL,NULL);
973 EXIT_IF(nufael == NULL,NULL,NULL);
977 typ_con, mode_coo, connectivite,
978 &inoele,nomele,&inuele,numele,&inufael,nufael );
980 EXIT_IF(ret < 0,
"lors de la lecture des mailles",NULL);
983 fprintf(stdout,
"\n(**************************)\n");
984 fprintf(stdout,
"(* ELEMENTS DU MAILLAGE : *)\n");
985 fprintf(stdout,
"(**************************)\n");
990 fprintf(stdout,
"\n- Mailles de type %s : ",
nommai[i]);
991 fprintf(stdout,
"\n - Connectivité : ");
992 for (j=0;j<nmailles[i]*taille;j++) {
994 fprintf(stdout,
"\n [ %5"MED_IFORMAT" ] : ", (j/taille +1) );
996 fprintf(stdout,
"\n");
997 fprintf(stdout,
" %9"MED_IFORMAT" ",*(connectivite+j));
1001 fprintf(stdout,
"\n - Noms : \n");
1002 for (j=0;j<nmailles[i];j++) {
1005 fprintf(stdout,
" %s ",str);
1009 fprintf(stdout,
"\n - Numeros :\n");
1010 for (j=0;j<nmailles[i];j++)
1011 fprintf(stdout,
" "IFORMAT" ",*(numele+j));
1013 fprintf(stdout,
"\n - Numéros de familles : \n");
1014 for (j=0;j<nmailles[i];j++)
1016 fprintf(stdout,
" "IFORMAT" ",*(nufael+j));
1018 fprintf(stdout,
" %d ",0);
1019 fprintf(stdout,
"\n");
1034 const char *
const nommaa,
1054 EXIT_IF(nmpolygones < 0,
"lors de la lecture du nombre de mailles polygone\n",
1056 if (nmpolygones > 0 ) nmpolygones--;
else nmpolygones=0;
1059 fprintf(stdout,
"- Nombre de mailles de type %s : "IFORMAT" \n",
1060 polytypename,nmpolygones);
1062 polytypename[0]=
'\0';
1067 const char *
const nommaa,
1099 EXIT_IF(taille < 0,
"lors de la lecture des parametres des mailles polygones",
1104 EXIT_IF(indexp == NULL,NULL,NULL);
1106 EXIT_IF(connectivite == NULL,NULL,NULL);
1108 EXIT_IF(numele == NULL,NULL,NULL);
1110 EXIT_IF(nufael == NULL,NULL,NULL);
1111 nomele = (
char *) malloc(
sizeof(
char)*
MED_SNAME_SIZE*nmpolygones+1);
1112 EXIT_IF(nomele == NULL,NULL,NULL);
1116 indexp,connectivite);
1118 EXIT_IF(ret < 0,
"lors de la lecture des connectivites des mailles polygones",
1136 fprintf(stdout,
"\n\n- Mailles de type %s : ",polytypename);
1137 for (i=0;i<nmpolygones;i++) {
1138 fprintf(stdout,
"\n >> Maille MED_POLYGONE "IFORMAT" : \n",i+1);
1139 fprintf(stdout,
"\n - Connectivité : ");
1140 ind1 = *(indexp+i)-1;
1141 ind2 = *(indexp+i+1)-1;
1142 for (j=ind1;j<ind2;j++)
1143 printf(
" "IFORMAT" ",*(connectivite+j));
1147 fprintf(stdout,
"\n - Nom : %s \n",tmp);
1150 fprintf(stdout,
"\n - Numero : "IFORMAT" \n",*(numele+i));
1153 fprintf(stdout,
"\n - Numéro de famille : "IFORMAT" \n",*(nufael+i));
1155 fprintf(stdout,
"\n - Numéro de famille : %d \n",0);
1157 polytypename[0]=
'\0';
1172 const char *
const nommaa,
1183 EXIT_IF(npolyedres < 0,
"lors de la lecture du nombre de mailles polyedre \n",
1185 if ( npolyedres > 0 ) npolyedres--;
else npolyedres=0;
1187 fprintf(stdout,
"- Nombre de mailles de type MED_POLYEDRE : "IFORMAT" \n",
1195 const char *
const nommaa,
1223 EXIT_IF(taille < 0,
"lors de la lecture des parametres des mailles polyedres",
1229 EXIT_IF(nindn < 0,
"lors de la lecture des parametres des mailles polyedres",
1235 EXIT_IF(indexf == NULL,NULL,NULL);
1237 EXIT_IF(indexn == NULL,NULL,NULL);
1239 EXIT_IF(connectivite == NULL,NULL,NULL);
1241 EXIT_IF(numele == NULL,NULL,NULL);
1243 EXIT_IF(nufael == NULL,NULL,NULL);
1244 nomele = (
char *) malloc(
sizeof(
char)*
MED_SNAME_SIZE*npolyedres+1);
1245 EXIT_IF(nomele == NULL,NULL,NULL);
1248 indexf,indexn,connectivite);
1250 "lors de la lecture de la connectivite des mailles polyedres",
1264 fprintf(stdout,
"\n\n- Mailles de type MED_POLYEDRE : ");
1265 for (i=0;i<npolyedres;i++) {
1266 fprintf(stdout,
"\n >> Maille MED_POLYEDRE "IFORMAT" : \n",i+1);
1267 fprintf(stdout,
"\n - Connectivité : \n");
1268 nfa = *(indexf+i+1) - *(indexf+i);
1270 ind1 = *(indexf+i) - 1;
1271 for (j=0;j<nfa;j++) {
1275 ind2 = *(indexn+ind1+j) - 1;
1276 nnoe = *(indexn+ind1+j+1) - *(indexn+ind1+j);
1277 fprintf(stdout,
" - Face "IFORMAT" : [ ", j+1);
1278 for (k=0;k<nnoe;k++)
1279 printf(
" "IFORMAT" ",*(connectivite+ind2+k));
1283 nfa = *(indexf+i+1) - *(indexf+i);
1286 ind1 = *(indexf+i) - 1;
1289 *(connectivite+ind1+j),*(indexn+ind1+j));
1295 fprintf(stdout,
"\n - Nom : %s \n",tmp);
1298 fprintf(stdout,
"\n - Numero : "IFORMAT" \n",*(numele+i));
1300 fprintf(stdout,
"\n - Numéro de famille : "IFORMAT" \n",*(nufael+i));
1302 fprintf(stdout,
"\n - Numéro de famille : %d \n",0);
1319 const char *
const nommaa,
1332 EXIT_IF(nfaces < 0,
"lors de la lecture du nombre de faces",NULL);
1337 fprintf (stdout,
"- Nombre de faces de type %s : "IFORMAT" \n",
1344 const char *
const nommaa,
1364 if (nfaces[i] > 0 ) {
1368 EXIT_IF(ret < 0,
"lors de la lecture des caractéristiques des mailles",NULL);
1371 connectivite = (
med_int*)malloc(
sizeof(
med_int)*taille*nfaces[i]);
1372 EXIT_IF(connectivite == NULL,NULL,NULL);
1374 EXIT_IF(nomele == NULL,NULL,NULL);
1376 EXIT_IF(numele == NULL,NULL,NULL);
1378 EXIT_IF(nufael == NULL,NULL,NULL);
1383 &inoele,nomele,&inuele,numele,&inufael,nufael );
1384 EXIT_IF(ret < 0,
"lors de la lecture des faces",NULL);
1388 fprintf(stdout,
"\n- Faces de type %s : ",
nomfac[i]);
1389 fprintf(stdout,
"\n - Connectivité : ");
1390 for (j=0;j<nfaces[i]*taille;j++) {
1392 fprintf(stdout,
"\n [ %5"MED_IFORMAT" ] : ", (j/taille+1) );
1394 fprintf(stdout,
"\n");
1395 fprintf(stdout,
" %9"MED_IFORMAT" ",*(connectivite+j));
1399 fprintf(stdout,
"\n - Noms : \n");
1400 for (j=0;j<nfaces[i];j++) {
1403 fprintf(stdout,
" %s ",str);
1407 fprintf(stdout,
"\n - Numeros :\n");
1408 for (j=0;j<nfaces[i];j++)
1409 fprintf(stdout,
" "IFORMAT" ",*(numele+j));
1411 fprintf(stdout,
"\n - Numéros de familles : \n");
1412 for (j=0;j<nfaces[i];j++)
1414 fprintf(stdout,
" "IFORMAT" ",*(nufael+j));
1416 fprintf(stdout,
" %d ",0);
1430 const char *
const nommaa,
1441 EXIT_IF(nfpolygones < 0,
"lors de la lecture du nombre de faces polygone \n",
1443 if (nfpolygones > 0 ) nfpolygones--;
else nfpolygones=0;
1445 fprintf(stdout,
"- Nombre de faces de type MED_POLYGONE : "IFORMAT" \n",
1452 const char *
const nommaa,
1475 EXIT_IF(taille < 0,
"lors de la lecture des parametres des faces polygones",
1480 EXIT_IF(indexp == NULL,NULL,NULL);
1482 EXIT_IF(connectivite == NULL,NULL,NULL);
1484 EXIT_IF(numele == NULL,NULL,NULL);
1486 EXIT_IF(nufael == NULL,NULL,NULL);
1487 nomele = (
char *) malloc(
sizeof(
char)*
MED_SNAME_SIZE*nfpolygones+1);
1488 EXIT_IF(nomele == NULL,NULL,NULL);
1492 indexp,connectivite);
1493 EXIT_IF(ret < 0,
"lors de la lecture des connectivites des faces polygones", NULL);
1509 fprintf(stdout,
"\n\n- Faces de type MED_POLYGONE : ");
1510 for (i=0;i<nfpolygones;i++) {
1511 fprintf(stdout,
"\n >> Face MED_POLYGONE "IFORMAT" : \n",i+1);
1512 fprintf(stdout,
"\n - Connectivité : ");
1513 ind1 = *(indexp+i)-1;
1514 ind2 = *(indexp+i+1)-1;
1515 for (j=ind1;j<ind2;j++)
1516 fprintf(stdout,
" "IFORMAT" ",*(connectivite+j));
1520 fprintf(stdout,
"\n - Nom : %s \n",tmp);
1523 fprintf(stdout,
"\n - Numero : "IFORMAT" \n",*(numele+j));
1525 fprintf(stdout,
"\n - Numéro de famille : "IFORMAT" \n",*(nufael+i));
1527 fprintf(stdout,
"\n - Numéro de famille : %d \n",0);
1543 const char *
const nommaa,
1555 EXIT_IF(naretes < 0,
"lors de la lecture du nombre d'aretes",NULL);
1560 "- Nombre d'aretes de type %s : "IFORMAT" \n",
nomare[indice],naretes);
1566 const char *
const nommaa,
1570 const med_int *
const naretes,
1586 if (naretes[i] > 0) {
1589 EXIT_IF(ret < 0,
"lors de la lecture des caractéristiques des mailles",NULL);
1592 connectivite = (
med_int*)malloc(
sizeof(
med_int)*taille*naretes[i]);
1593 EXIT_IF(connectivite == NULL,NULL,NULL);
1594 nomele = (
char*)malloc(
sizeof(
char)*
MED_SNAME_SIZE*naretes[i]+1);
1595 EXIT_IF(nomele == NULL,NULL,NULL);
1597 EXIT_IF(numele == NULL,NULL,NULL);
1599 EXIT_IF(nufael == NULL,NULL,NULL);
1604 &inoele,nomele,&inuele,numele,&inufael,nufael );
1605 EXIT_IF(ret < 0,
"lors de la lecture des aretes",
1610 fprintf(stdout,
"\n- Aretes de type %s : ",
nomare[i]);
1611 fprintf(stdout,
"\n - Connectivité : ");
1612 for (j=0;j<naretes[i]*taille;j++) {
1614 fprintf(stdout,
"\n [ %5"MED_IFORMAT" ] : ", (j/taille+1) );
1616 fprintf(stdout,
"\n");
1617 fprintf(stdout,
" %9"MED_IFORMAT" ",*(connectivite+j));
1621 fprintf(stdout,
"\n - Noms : \n");
1622 for (j=0;j<naretes[i];j++) {
1625 fprintf(stdout,
" %s ",str);
1629 fprintf(stdout,
"\n - Numeros :\n");
1630 for (j=0;j<naretes[i];j++)
1631 fprintf(stdout,
" "IFORMAT" ",*(numele+j));
1633 fprintf(stdout,
"\n - Numéros de familles : \n");
1634 for (j=0;j<naretes[i];j++)
1636 fprintf(stdout,
" "IFORMAT" ",*(nufael+j));
1638 fprintf(stdout,
" %d ",0);
1676 const char *
const nomcoo,
1677 const char *
const unicoo,
1681 char** geotypename_elst,
1682 const int lecture_en_tete_seulement)
1691 med_int nmpolygones,nmpolygones2, npolyedres, nfpolygones;
1699 med_int _nmodels=0,*_nmailles_elst = NULL;
1701 char *_geotypename_elst = NULL;
1712 "Erreur à la lecture du nombre de type géométrique pour le type d'entités MED_STRUCT_ELEMENT",NULL);
1716 _geotypename_elst = (
char *) malloc(_nmodels*
sizeof(
char)*(
MED_NAME_SIZE+1));
1718 for (i=0; i < _nmodels; i++) {
1723 *nmodels = _nmodels;
1724 *geotype_elst = _geotype_elst;
1725 *geotypename_elst = _geotypename_elst;
1781 lecture_noeuds_maillage_non_structure(fid,nommaa,numdt,numit,mdim,edim,nnoe,mode_coo,nomcoo,unicoo,rep);
1805 _geotype_elst,_geotypename_elst,_nmailles_elst,mode_coo);
1814 if (nmpolygones > 0)
1818 if (nmpolygones2 > 0)
1829 if (nfpolygones > 0)
1864 const char *
const nommaa,
1882 EXIT_IF(ret < 0,
"a la lecture du type d'une grille ",NULL);
1889 fprintf(stdout,
"- Type de grille : MED_GRILLE_CARTESIENNE \n");
1891 fprintf(stdout,
"- Type de grille : MED_GRILLE_POLAIRE \n");
1892 for (axe=1;axe<=mdim;axe++) {
1911 "lors de la lecture de la taille d'un indice d'une grille",
1913 *nnoe = nind[axe - 1] * (*nnoe);
1914 *nmai = (nind[axe - 1] - 1) * (*nmai);
1916 "- Taille de l'indice de l'axe "IFORMAT" des coordonnees : "IFORMAT" \n",
1922 fprintf(stdout,
"- Type de grille : MED_GRILLE_DESTRUCTUREE \n");
1925 EXIT_IF(*nnoe < 0,
"lors de la lecture du nombre de noeuds du maillage "
1930 EXIT_IF(structure_grille == NULL,NULL,NULL);
1934 EXIT_IF(ret < 0,
"lors de la lecture de la structure de la grille",
1936 fprintf(stdout,
"- Structure de la grille : [ ");
1937 for (j=0;j<mdim;j++) {
1938 *nmai = (*(structure_grille+j) - 1) * (*nmai);
1939 fprintf(stdout,
" "IFORMAT" ",*(structure_grille+j));
1941 fprintf(stdout,
" ] \n");
1943 free(structure_grille);
1948 EXIT_IF(-1,
"Type de grille non reconnu.",nommaa);
1952 fprintf(stdout,
"- Nombre de noeuds : "IFORMAT" \n",*nnoe);
1953 fprintf(stdout,
"- Nombre de mailles : "IFORMAT" \n",*nmai);
1960 const char *
const nommaa,
1967 const char *
const comp,
1968 const char *
const unit,
1979 char *nomnoe = NULL;
1982 fprintf(stdout,
"\n(*************************)\n");
1983 fprintf(stdout,
"(* NOEUDS DE LA GRILLE : *)\n");
1984 fprintf(stdout,
"(*************************)\n");
1991 for (axe = 1; axe<=mdim; axe++) {
1994 EXIT_IF(indices == NULL,NULL,NULL);
1998 EXIT_IF(ret < 0,
"lors de la lecture d'un tableau d'indice",
2002 for (j=0;j<nind[axe - 1];j++)
2003 fprintf(stdout,
" %f ",*(indices+j));
2013 EXIT_IF(coo == NULL,NULL,NULL);
2017 EXIT_IF(ret < 0,
"lors de la lecture des noeuds du maillage",NULL);
2019 fprintf(stdout,
"- Nom des coordonnees : \n");
2020 for (i=0;i<edim;i++) {
2023 fprintf(stdout,
" %s ",str);
2025 fprintf(stdout,
"\n- Unites des coordonnees : \n");
2026 for (i=0;i<edim;i++) {
2029 fprintf(stdout,
" %s ",str);
2032 fprintf(stdout,
"\n - Coordonnees des noeuds : [ ");
2033 for (j=0;j<nnoe*edim;j++)
2034 fprintf(stdout,
" %f ",*(coo+j));
2035 fprintf(stdout,
" ] \n");
2044 EXIT_IF(-1,
"Type de grille non reconnu.",nommaa);
2055 EXIT_IF(numnoe == NULL,NULL,NULL);
2057 EXIT_IF(nomnoe == NULL,NULL,NULL);
2059 EXIT_IF(nufano == NULL,NULL,NULL);
2063 if (ret < 0) ret=0;
else inufael=
MED_TRUE;
2065 EXIT_IF(ret < 0,
"lors de la lecture des numeros de familles des noeuds",
2069 fprintf(stdout,
"\n- Numeros des familles des noeuds : \n");
2070 for (i=0;i<nnoe;i++)
2072 fprintf(stdout,
" "IFORMAT" ",*(nufano+i));
2074 fprintf(stdout,
" %d ",0);
2075 fprintf(stdout,
"\n");
2081 fprintf(stdout,
"\n- Noms des noeuds : \n");
2082 for (i=0;i<nnoe;i++) {
2085 fprintf(stdout,
" %s ",str);
2093 fprintf(stdout,
"\n- Numeros des noeuds : \n");
2094 for (i=0;i<nnoe;i++)
2095 fprintf(stdout,
" "IFORMAT" ",*(numnoe+i));
2109 const char *
const nommaa,
2119 char *nomele = NULL;
2125 fprintf(stdout,
"\n(***************************)\n");
2126 fprintf(stdout,
"(* ELEMENTS DE LA GRILLE : *)\n");
2127 fprintf(stdout,
"(***************************)\n");
2152 EXIT_IF(numele == NULL,NULL,NULL);
2154 EXIT_IF(nomele == NULL,NULL,NULL);
2156 EXIT_IF(nufael == NULL,NULL,NULL);
2161 for (i=0;i<nmai;i++)
2166 fprintf(stdout,
"\n- Numeros des familles des mailles : \n");
2167 for (i=0;i<nmai;i++)
2168 fprintf(stdout,
" "IFORMAT" ",*(nufael+i));
2169 fprintf(stdout,
"\n");
2175 fprintf(stdout,
"\n - Noms : \n");
2176 for (i=0;i<nmai;i++) {
2179 fprintf(stdout,
" %s ",str);
2187 fprintf(stdout,
"\n - Numeros :\n");
2188 for (i=0;i<nmai;i++)
2189 fprintf(stdout,
" "IFORMAT" ",*(numele+i));
2202 const char *
const nommaa,
2208 const char *
const comp,
2209 const char *
const unit,
2210 const int lecture_en_tete_seulement)
2241 if (lecture_en_tete_seulement)
2247 lecture_noeuds_maillage_structure(fid,nommaa,numdt,numit,mdim,edim,nind,nnoe,comp,unit,type,mode_coo);
2273 const char *
const maillage,
2278 const char*
const geotypename_elst,
2279 const char *
const nomcha,
2280 const char *
const dtunit,
2283 const char *
const comp,
2284 const char *
const unit,
2289 int i,j,k,l,m,n,nb_geo=0;
2290 med_int nbpdtnor=0,pflsize,*pflval,ngauss=0,ngroup,*vale=NULL,nval;
2291 med_int numdt=0,numo=0,_nprofile;
2292 med_int meshnumdt=0,meshnumit=0;
2305 size_t _bannerlen=255;
2306 size_t _bannerlen1=0,_bannershift1=0;
2308 char * _bannerstr1=NULL;
2309 size_t _bannerlen2=0,_bannershift2=0;
2311 char * _bannerstr2=NULL;
2313 const char *
const * AFF;
2315 const char * * AFF_STRUCT = NULL;
2340 AFF_STRUCT = (
const char * *) calloc(
sizeof(
const char * ),nmodels+1);
2341 for(i=0;i<nmodels;++i) AFF_STRUCT[i+1]= &geotypename_elst[(
MED_NAME_SIZE+1)*i];
2348 for (k=1;k<=nb_geo;k++) {
2352 if (nbpdtnor < 1 )
continue;
2354 for (j=0;j<nbpdtnor;j++) {
2357 &nmesh, maa_ass, &localmesh, &meshnumdt, &meshnumit ) <0) {
2358 MESSAGE(
"Erreur a la demande d'information sur (pdt,nor) : ");
2364 for (i=0;i< nmesh;++i) {
2367 meshname,pflname,locname ) ) < 0 ) {
2368 MESSAGE(
"Erreur a la demande du nombre de profils referencés par le champ : ");
2375 for (l=0;l<_nprofile;l++) {
2379 locname, &ngauss) ) < 0 ) {
2380 MESSAGE(
"Erreur a la lecture du nombre de valeurs du champ : ");
2387 if ( (!strcmp(meshname,maillage)) && (meshnumdt == mnumdt) && (meshnumit == mnumit) ) {
2390 _bannerstr1 =
"(* CHAMP |%s| A L'ÉTAPE DE CALCUL (n°dt,n°it)="
2393 _bannerstr2 =
"(* SUR LE MAILLAGE |%s| A L'ÉTAPE DE CALCUL (n°dt,n°it)="
2394 "(% 2.2"MED_IFORMAT
",% 2.2"MED_IFORMAT
") : %.*s*)\n";
2395 snprintf(_temp1,
MAXBANNERLEN+1,_bannerstr1,nomcha,numdt,numo,0,
"");
2396 snprintf(_temp2,
MAXBANNERLEN+1,_bannerstr2,meshname,meshnumdt,meshnumit,0,
"");
2397 _bannerlen1 = strlen(_temp1);
2398 _bannerlen2 = strlen(_temp2);
2399 _bannerlen=
MAX(_bannerlen1,_bannerlen2);
2400 if (_bannerlen1>_bannerlen2) {
2401 _bannershift1 = 0; _bannershift2 = _bannerlen1-_bannerlen2;
2403 _bannershift2 = 0; _bannershift1 = _bannerlen2-_bannerlen1;
2405 fprintf(stdout,
"\n(");
2406 for (i=0;i< _bannerlen-6; i++) fprintf(stdout,
"*");
2407 fprintf(stdout,
")\n");
2408 fprintf(stdout,_bannerstr1,nomcha,numdt,numo,_bannershift1,
MED_NAME_BLANK);
2409 fprintf(stdout,_bannerstr2,meshname,meshnumdt,meshnumit,_bannershift2,
MED_NAME_BLANK);
2410 fprintf(stdout,
"(");
2411 for (i=0;i< _bannerlen-6; i++) fprintf(stdout,
"*");
2412 fprintf(stdout,
")\n");
2424 fprintf(stdout,
"- Valeur de la date du champ %f [%s] : \n",dt,dtunit);
2425 fprintf(stdout,
"- Type des composantes du champ : %d\n",typcha);
2426 fprintf(stdout,
"- Nombre de composantes par valeur : "IFORMAT"\n",ncomp);
2427 fprintf(stdout,
"- Unité des composantes : |%s|\n",unit);
2428 fprintf(stdout,
"- Nom des composantes : |%s|\n",comp);
2430 printf(
"\t- Il y a "IFORMAT" entités qui portent des valeurs en mode %i."
2431 "\n\t Chaque entite %s de type geometrique %s associes au profil |%s| a "IFORMAT" point(s) d'intégration \n",
2432 nval,
USER_MODE,AFF_ENT[(
int)entite],AFF[k],pflname,ngauss);
2438 MESSAGE(
"Erreur a la lecture de la taille du lien : ");
2442 lien = (
char *)malloc(lnsize*
sizeof(
char) + 1);
2443 EXIT_IF(lien == NULL,NULL,NULL);
2445 if (
MEDlinkRd(fid, maa_ass, lien) < 0 ) {
2446 MESSAGE(
"Erreur a la lecture du lien : ");
2450 lien[lnsize] =
'\0';
2451 printf(
"\tLe maillage |%s| est porte par un fichier distant |%s|\n",maa_ass,lien);
2461 EXIT_IF(valr == NULL,NULL,NULL);
2465 (
unsigned char*) valr) < 0 ) {
2466 MESSAGE(
"Erreur a la lecture des valeurs du champ : ");
2474 EXIT_IF(vale == NULL,NULL,NULL);
2478 (
unsigned char*) vale) < 0 ) {
2479 MESSAGE(
"Erreur a la lecture des valeurs du champ : ");
2486 if ( strlen(locname) && (_nprofile > 1) )
2487 printf(
"\t- Modèle de localisation des points de Gauss de nom |%s|\n",locname);
2490 ngroup = (type_geo[k] % 100);
2498 printf(
"\t- Valeurs :\n\t");
2499 for (m=0;m<(nval*ngauss)/ngroup;m++) {
2501 for (n=0;n<ngroup*ncomp;n++)
2503 printf(
" %f ",*(valr+(m*ngroup*ncomp)+n));
2505 printf(
" "IFORMAT
" ",*(vale+(m*ngroup*ncomp)+n));
2513 printf(
"\t- Valeurs :\n\t");
2514 for (m=0;m<ncomp;m++) {
2516 for (n=0;n<(nval*ngauss);n++)
2518 printf(
" %f ",*(valr+(m*nval)+n));
2520 printf(
" "IFORMAT
" ",*(vale+(m*nval)+n));
2531 if ( valr ) {free(valr);valr = NULL;}}
2533 if (vale) { free(vale);vale = NULL; }
2537 printf(
"\t- Profil : MED_NOPFL\n");
2540 MESSAGE(
"Erreur a la lecture du nombre de valeurs du profil : ");
2545 printf(
"\t- Profil : |%s| de taille "IFORMAT
"\n",pflname,pflsize);
2548 EXIT_IF(pflval == NULL,NULL,NULL);
2550 MESSAGE(
"Erreur a la lecture des valeurs du profil : ");
2556 for (m=0;m<pflsize;m++) printf(
" "IFORMAT
" ",*(pflval+m));
2586 const char *
const maillage,
2592 const char* geotypename_elst,
2593 const int lecture_en_tete_seulement)
2610 EXIT_IF(ncha < 0,
"lors de la lecture du nombre de champs",NULL);
2612 if ( !strlen(maillage) || lecture_en_tete_seulement ) {
2613 fprintf(stdout,
"\n(************************)\n");
2614 fprintf(stdout,
"(* CHAMPS DU MAILLAGE : *)\n");
2615 fprintf(stdout,
"(************************)\n");
2616 fprintf(stdout,
"- Nombre de champs : "IFORMAT" \n",ncha);
2625 for (i =0;i<ncha;i++) {
2630 MESSAGE(
"Erreur à la lecture du nombre de composantes : ");
2638 EXIT_IF(comp == NULL,NULL,NULL);
2640 EXIT_IF(unit == NULL,NULL,NULL);
2643 &typcha, comp, unit, dtunit, &ncstp) < 0 ) {
2644 MESSAGE(
"Erreur à la demande d'information sur les champs : ");
2649 if ( !strlen(maillage) || lecture_en_tete_seulement ) {
2650 printf(
"\nChamp numero : |%d| \n",i+1);
2651 printf(
"Nom du champ : |%s| de type |%d|\n",nomcha,typcha);
2652 printf(
"Nom des composantes : |%s|\n",comp);
2653 printf(
"Unites des composantes : |%s| \n",unit);
2655 printf(
"Unité des dates : |%s|\n",dtunit);
2657 printf(
"Nombre d'étapes de calcul : |"IFORMAT"| \n",ncstp);
2661 if (lecture_en_tete_seulement) {
2668 lret =
getFieldsOn(fid, maillage, mnumdt, mnumit, nmodels,geotype_elst,geotypename_elst,
2669 nomcha, dtunit, typcha, ncomp, comp, unit,
MED_NODE,mode_coo, ncstp);
2672 if (lret == 0) lret =
getFieldsOn(fid, maillage, mnumdt, mnumit , nmodels,geotype_elst,geotypename_elst,
2673 nomcha, dtunit, typcha, ncomp, comp, unit,
MED_CELL,mode_coo, ncstp);
2674 else {
MESSAGE(
"Erreur à la lecture des champs aux noeuds "); ret = -1;
continue;}
2676 if (lret == 0) lret =
getFieldsOn(fid, maillage, mnumdt, mnumit , nmodels,geotype_elst,geotypename_elst,
2678 else {
MESSAGE(
"Erreur à la lecture des champs aux mailles "); ret = -1;
continue;}
2680 if (lret == 0) lret =
getFieldsOn(fid, maillage, mnumdt, mnumit , nmodels,geotype_elst,geotypename_elst,
2682 else {
MESSAGE(
"Erreur à la lecture des champs aux faces "); ret = -1;
continue;}
2684 if (lret == 0) lret =
getFieldsOn(fid, maillage, mnumdt, mnumit , nmodels,geotype_elst,geotypename_elst,
2685 nomcha, dtunit, typcha, ncomp, comp, unit,
MED_NODE_ELEMENT,mode_coo, ncstp);
2686 else {
MESSAGE(
"Erreur a la lecture des champs aux aretes "); ret = -1;
continue;}
2688 if (lret != 0) {
MESSAGE(
"Erreur a la lecture des champs aux noeuds des mailles "); ret = -1;};
2691 lret =
getFieldsOn(fid, maillage, mnumdt, mnumit , nmodels, geotype_elst,geotypename_elst,
2693 if (lret != 0) {
MESSAGE(
"Erreur a la lecture des champs aux éléments de sructure "); ret = -1;};
2715 int lecture_en_tete_seulement)
2731 EXIT_IF(n < 0,
"lors de la lecture du nombre de scalaires",NULL);
2734 fprintf(stdout,
"\n(*******************************)\n");
2735 fprintf(stdout,
"(* VARIABLES SCALAIRES : *)\n");
2736 fprintf(stdout,
"(*******************************)\n\n");
2737 fprintf(stdout,
"- Nombre de variables scalaires : "IFORMAT"\n",n);
2739 if (lecture_en_tete_seulement)
2742 for (i=1;i<=n;i++) {
2747 EXIT_IF(ret < 0,
"lors de la lecture des parametres d'un scalaire",NULL);
2748 fprintf(stdout,
"- Scalaire n°"IFORMAT" de nom %s \n",i,nom_scalaire);
2750 fprintf(stdout,
" Type flottant. \n");
2752 fprintf(stdout,
" Type entier. \n");
2753 printf(
" Description associee : [%s] \n",description);
2758 "lors de la lecture du nombre de pas de temps d'un scalaire"
2760 fprintf(stdout,
" Nombre de valeurs stockees : "IFORMAT" \n",npdt);
2762 for (j=1;j<=npdt;j++) {
2766 "lors de la lecture des parametres d'un pas de temps d'un scalaire",
2770 fprintf(stdout,
" - Aucun de pas de temps \n");
2773 " - Pas de de temps de numero "IFORMAT" de valeur %f [%s] \n",numdt,
2776 fprintf(stdout,
" - Aucun numero d'ordre \n");
2778 fprintf(stdout,
" - Numero d'ordre : "IFORMAT" \n",numo);
2782 fprintf(stdout,
" - Valeur : %f \n",valr);
2786 fprintf(stdout,
" - Valeur : "IFORMAT" \n",vali);
2788 EXIT_IF(ret < 0,
"lors de la lecture de la valeur d'un scalaire",NULL);
2808 int lecture_en_tete_seulement)
2818 EXIT_IF(npro < 0,
"lors de la lecture du nombre de profils",NULL);
2821 fprintf(stdout,
"\n(*************)\n");
2822 fprintf(stdout,
"(* PROFILS : *)\n");
2823 fprintf(stdout,
"(*************)\n");
2824 printf(
"\nNombre de profils stockes : "IFORMAT"\n\n",npro);
2827 for (i=1 ; i <= npro ; i++ ) {
2832 printf(
"\t- Profil n°%i de nom |%s| et de taille "IFORMAT"\n",i,pflname,nval);
2835 MESSAGE(
"Erreur a la lecture des valeurs du profil : ");
2841 for (j=0;j<nval;j++) printf(
" "IFORMAT" ",*(pflval+j));
2862 int lecture_en_tete_seulement)
2865 int _i =0,_j=0,_k=0, _n=0,_nvalue=0;
2878 med_int _nconstantattribute=0;
2880 med_int _nvariableattribute=0;
2891 unsigned char * _value=NULL;
2892 void (*_printf)(
const void*);
2896 EXIT_IF(_nstructelement < 0,
"lors de la lecture du nombre d'éléments de structure",NULL);
2898 if(_nstructelement) {
2899 fprintf(stdout,
"\n(*************************************)\n");
2900 fprintf(stdout,
"(* MODELES D'ELEMENTS DE STRUCTURE : *)\n");
2901 fprintf(stdout,
"(*************************************)\n");
2902 printf(
"\nNombre d'éléments de structure : "IFORMAT"\n\n",_nstructelement);
2905 for ( _i=1; _i<= _nstructelement; ++_i) {
2908 &_entitytype,&_nnode,&_ncell,&_geocelltype,&_nconstantattribute,&_anyprofile,
2909 &_nvariableattribute );
2910 EXIT_IF(_ret < 0,
"lors de la demande d'information sur les éléments de structure",NULL);
2912 fprintf(stdout,
"\nElément de structure n°%d |%s| de type géométrique n°%d et de dimension "IFORMAT"\n",
2913 _i,_elementname,_geotype,_elementdim);
2914 if ( strlen(_supportmeshname) ) {
2915 fprintf(stdout,
"\t Maillage support de nom |%s|",_supportmeshname);
2918 fprintf(stdout,
" avec "IFORMAT" maille(s) de type |%s| et",_ncell,_geocelltypename);
2921 fprintf(stdout,
" avec "IFORMAT" noeud(s)\n",_nnode);
2923 fprintf(stderr,
"\n Erreur : les noeuds doivent être définis s'il existe un maillage support\n");
2926 fprintf(stdout,
"\t Maillage support implicite sur noeud\n");
2928 fprintf(stdout,
"\t Nombre d'attribut(s) constant(s) : "IFORMAT"",_nconstantattribute);
2929 if (_anyprofile) fprintf(stdout,
", avec profil.\n");
else fprintf(stdout,
", sans profil.\n");
2931 if ( _nconstantattribute ) {
2932 for (_j=1;_j<=_nconstantattribute;++_j) {
2934 _constattname, &_constatttype, &_ncomponent,
2935 &_attentitytype, _profilename, &_profilesize );
2936 EXIT_IF(_ret < 0,
"lors de la demande d'information sur les attributs constants des éléments de structure",NULL);
2938 fprintf(stdout,
"\t\t Attribut constant de nom |%s| de type %d à "IFORMAT" composantes\n",
2939 _constattname,_constatttype,_ncomponent);
2941 if (!_profilesize) {
2942 if (_attentitytype ==
MED_NODE) _nvalue = _nnode;
else _nvalue=_ncell;
2944 _nvalue = _profilesize;
2946 _n = _ncomponent*_nvalue;
2949 _value = (
unsigned char *) malloc(_n*_atttypesize);
2953 if (_ret < 0 ) free(_value);
2954 EXIT_IF(_ret < 0,
"lors de la lecture des valeurs des attributs constants",NULL);
2958 fprintf(stdout,
"\t\t - Valeurs de l'attribut sur les d'entité |%s|",
2961 fprintf(stdout,
" avec un profil |%s| de taille "IFORMAT": ",_profilename,_profilesize);
2963 fprintf(stdout,
" sans profil : ");
2965 for (_k=0;_k<_nvalue*_ncomponent;_k++) {
2967 if ( !(_k % _ncomponent) )
2968 fprintf(stdout,
"\n [ %5"MED_IFORMAT" ] : ", (_k/_ncomponent +1) );
2969 _printf( (
void *)( (
char *)(_value) + _k*_atttypesize) );
2979 fprintf(stdout,
"\t Nombre d'attribut(s) variable(s) : "IFORMAT"\n",_nvariableattribute);
2980 if ( _nvariableattribute ) {
2981 for (_j=1;_j<=_nvariableattribute;++_j) {
2983 EXIT_IF(_ret < 0,
"lors de la lecture des valeurs des attributs variables",NULL);
2984 fprintf(stdout,
"\t\t Attribut variable de nom |%s| de type %d à "IFORMAT" composantes\n",
2985 _varattname,_varatttype,_ncomponent);
3006 int lecture_en_tete_seulement)
3015 med_int _geodim=0,_geonnodes=0;
3021 int _basisfuncit =0;
3026 int _coefficientit =0;
3031 fprintf(stdout,
"\n(********************************)\n");
3032 fprintf(stdout,
"(* FONCTIONS D'INTERPOLATION : *)\n");
3033 fprintf(stdout,
"(********************************)\n");
3034 printf(
"\nNombre de fonctions d'interpolation : "IFORMAT"\n\n",_ninterp);
3037 for ( _interpit=1; _interpit<= _ninterp; ++_interpit) {
3039 if (
MEDinterpInfo(fid,_interpit,_interpname,&_geotype,&_cellnodes,&_nbasisfunc,
3040 &_nvariable,&_maxdegree,&_nmaxcoefficient) < 0 ) {
3041 MESSAGE(
"Erreur à la demande d'information de la fonction d'interpolation n°");
3047 fprintf(stdout,
"Fonction d'interpolation n° %d |%s| sur le type géométrique |%s|\n",
3048 _interpit,_interpname, _geotypename);
3056 if ( _nbasisfunc == _geonnodes )
3057 fprintf(stdout,
"\t Les noeuds de construction sont les noeuds de la maille de référence.\n");
3059 MESSAGE(
"Erreur : le nombre de noeuds de construction "\
3060 "est différent du nombre de noeuds de la maille de référence.\n");
3072 fprintf(stdout,
"\t Il y a "IFORMAT" fonctions de base avec "IFORMAT" variables\n ",_nbasisfunc,_nvariable);
3073 fprintf(stdout,
"\t Le degré maximum des fonctions de base est "IFORMAT
" et possèdent au maximum "IFORMAT
" coefficients\n"
3074 ,_maxdegree,_nmaxcoefficient);
3078 _power = (
med_int*) calloc(
sizeof(
med_int),_nvariable*_nmaxcoefficient);
3080 for ( _basisfuncit=1; _basisfuncit<= _nbasisfunc; ++_basisfuncit) {
3083 if ( (_ret =
MEDinterpBaseFunctionRd( fid,_interpname,_basisfuncit,&_ncoefficient,_power,_coefficient) <0) ) {
3089 fprintf(stdout,
"\n\t Tableau de coefficients de la fonctions de base n° %d :\n\t",_basisfuncit);
3090 for ( _coefficientit=1; _coefficientit<= _ncoefficient; ++_coefficientit)
3091 fprintf(stdout,
" %4f ",_coefficient[_coefficientit]);
3093 fprintf(stdout,
"\n\t Tableau de puissances de la fonctions de base n° %d :\n\t",_basisfuncit);
3094 for ( _powerit=1; _powerit<= _nvariable*_ncoefficient; ++_powerit)
3095 fprintf(stdout,
" %4"MED_IFORMAT" ",_power[_powerit]);
3099 fprintf(stdout,
"\n");
3120 int lecture_en_tete_seulement)
3133 fprintf(stdout,
"\n(***********)\n");
3134 fprintf(stdout,
"(* LIENS : *)\n");
3135 fprintf(stdout,
"(***********)\n");
3136 printf(
"\nNombre de liens : "IFORMAT"\n\n",nln);
3139 for (i=1 ; i <= nln ; i++ ) {
3144 printf(
"\t- Lien n°%i de nom |%s| et de taille "IFORMAT"\n",i,nomlien,nval);
3146 lien = (
char * ) malloc((nval+1)*
sizeof(char));
3147 EXIT_IF(lien == NULL,NULL,NULL);
3149 if (
MEDlinkRd(fid, nomlien, lien ) < 0 ) {
3150 MESSAGE(
"Erreur a la lecture du lien : ");
3155 printf(
"\t\t|%s|\n\n",lien);
3178 int lecture_en_tete_seulement)
3181 med_int nloc=0,locsdim=0,ngauss=0;
3183 med_float *refcoo=NULL, *gscoo=NULL, *wg=NULL;
3200 fprintf(stdout,
"\n(********************************************)\n");
3201 fprintf(stdout,
"(* LOCALISATIONS DES POINTS D'INTEGRATION : *)\n");
3202 fprintf(stdout,
"(********************************************)\n");
3203 printf(
"\nNombre de localisations stockees : "IFORMAT"\n\n",nloc);
3206 for (i=1 ; i <= nloc ; i++ ) {
3208 geointerpname, ipointstructmeshname, &nsectionmeshcell,
3209 §iongeotype) < 0) {
3210 MESSAGE(
"Erreur a la demande d'information sur la localisation n° : ");
ISCRUTE_int(i);
3213 printf(
"\t- Loc. n°%i de nom |%s| de dimension "IFORMAT" avec "IFORMAT" pts de GAUSS \n",i,locname,locsdim,ngauss);
3225 if (strlen(ipointstructmeshname)) {
3227 MESSAGE(
"Erreur à la lecture du nom associé au sectiongeotype : ");
ISCRUTE_int(sectiongeotype);
3228 SSCRUTE(ipointstructmeshname);
3233 t1 = locnnodes*locsdim;
3234 t2 = ngauss*locsdim;
3241 MESSAGE(
"Erreur a la lecture des valeurs de la localisation : ");
3246 printf(
"\t Coordonnees de l'element de reference de type |%s| :\n\t\t",_locgeotypename);
3248 for (j=0;j<locnnodes*locsdim;j++) {
3250 fprintf(stdout,
"\n [ %5"MED_IFORMAT" ] : ", (j/locsdim + 1) );
3252 fprintf(stdout,
"\n\n ");
3253 fprintf(stdout,
" %-+9.6f ",*(refcoo+j));
3256 printf(
"\t Localisation des points de GAUSS : \n\t\t");
3258 for (j=0;j<ngauss*locsdim;j++) {
3260 fprintf(stdout,
"\n [ %5"MED_IFORMAT" ] : ", (j/locsdim + 1) );
3262 fprintf(stdout,
"\n\n ");
3263 fprintf(stdout,
" %-+9.6f ",*(gscoo+j));
3266 printf(
"\t Poids associes aux points de GAUSS :\n\t\t");
3267 for (j=0;j<t3;j++) printf(
" %f ",*(wg+j));
3270 if (strlen(ipointstructmeshname)) {
3271 printf(
"\t Maillage support de section d'élément de structure |%s|.\n",ipointstructmeshname);
3272 printf(
"\t Mailles des sections d'élément de structure de type |%s|.\n",sectiongeotypename);
3273 printf(
"\t Nombre de mailles par section d'élément de structure : "IFORMAT
".\n",nsectionmeshcell);
3275 if (strlen(geointerpname)) {
3276 printf(
"\t Tranformation géométrique associée à la localisation |%s|.\n",geointerpname);
3293 med_int majeur,mineur,release;
3298 ret = (int) access(fichier,F_OK);
3299 if (ret <0) {
SSCRUTE(fichier);}
3300 EXIT_IF(ret < 0,
"Le fichier n'est pas accessible ou n'existe pas ",
3305 EXIT_IF(ret < 0,
"Impossible de déterminer la compatibilité de format. ",
3308 EXIT_IF(!hdfok,
"Le fichier n'est pas dans un format HDF compatible ", fichier);
3309 EXIT_IF(!medok,
"Le fichier n'est pas dans un format MED compatible ", fichier);
3315 majeur,mineur,release);
3319 EXIT_IF( fid < 0,
"Ouverture du du fichier ",fichier);
3322 EXIT_IF(( (majeur < 2) || ( (majeur == 2) && (mineur < 2)) ),
"Le fichier est antérieur à la version 2.2", NULL);
3338 fprintf(stdout,
"- En-tete du fichier : %s \n",fichier_en_tete);
3349 fprintf(stdout,
"(*****************)\n");
3350 fprintf(stdout,
"(* PARAMETRAGE : *)\n");
3351 fprintf(stdout,
"(*****************)\n");
3352 fprintf(stdout,
"- Mode d'affichage des coordonnées des noeuds ? \n");
3353 fprintf(stdout,
" 1. Mode entrelacé : taper 1 \n");
3354 fprintf(stdout,
" 2. Mode non entrelacé : taper 2 \n");
3357 fprintf(stdout,
" Reponse : ");
3358 if (!scanf(
"%d",&reponse)) fgets(_temp, 256, stdin) ;
3359 }
while (reponse != 1 && reponse != 2);
3365 fprintf(stdout,
"- Connectivité des éléments ? \n");
3366 fprintf(stdout,
" 1. Nodale : taper 1 \n");
3367 fprintf(stdout,
" 2. Descendante : taper 2 \n");
3370 fprintf(stdout,
" Reponse : ");
3371 if (!scanf(
"%d",&reponse)) fgets(_temp, 256, stdin) ;
3372 }
while (reponse != 1 && reponse != 2);
3388 char *
const maillage_description,
3390 char *
const dtunit,
3391 char *
const nomcoo,
3392 char *
const unicoo,
3399 fprintf(stdout,
"\n(**********************************************************)\n");
3400 fprintf(stdout,
"(* INFORMATIONS GENERALES SUR LE MAILLAGE DE CALCUL N°%2.2d: *)\n",numero);
3401 fprintf(stdout,
"(**********************************************************)\n\n");
3404 ret =
MEDmeshInfo(fid, numero,nommaa,edim,mdim,type_maillage,maillage_description,
3405 dtunit,&sortingtype,nstep,rep,nomcoo,unicoo);
3406 EXIT_IF(ret < 0,
"Lecture des informations sur le maillage",NULL);
3409 fprintf(stdout,
"- Nom du maillage : <<%s>>\n",nommaa);
3410 fprintf(stdout,
"- Dimension du maillage : "IFORMAT"\n",*mdim);
3412 fprintf(stdout,
"- La dimension de l'espace est "IFORMAT" \n",*edim);
3414 fprintf(stdout,
"- Type du maillage : MED_NON_STRUCTURE \n");
3416 fprintf(stdout,
"- Type du maillage : MED_STRUCTURE \n");
3417 fprintf(stdout,
"- Description associee au maillage : %s\n",
3418 maillage_description);
3421 fprintf(stdout,
"- Nombre d'étapes de calcul associées au maillage : "IFORMAT"\n",
3424 fprintf(stdout,
"- Unité des dates d'étapes de calcul associées au maillage : %s\n",
3430 fprintf(stdout,
"- Nom universel du maillage : %s \n",nom_universel);
3449 int i=0,numero=0,firstmesh=0,lastmesh=0,meshit=0;
3452 int lecture_en_tete_seulement = 0;
3453 med_int mdim=0,nmaa=0,nmaasup=0;
3468 char *filename=NULL,*typ_con_param=NULL,*mode_coo_param=NULL;
3469 size_t _bannerlen=0;
3471 char * _bannerstr=NULL;
3477 char *_geotypename_elst = NULL;
3487 if (argc > 2 && strcmp(argv[1],
"--structure") == 0) {
3492 if ( (argc != 2) && (argc != 5) )
3494 fprintf(stderr,
"Utilisation mdump [--structure] monfichier.med [ NODALE|DESCENDANTE "
3495 "NO_INTERLACE|FULL_INTERLACE|LECTURE_EN_TETE_SEULEMENT N°MAILLAGE|0 pour tous ] \n");
3496 EXIT_IF( (argc != 2) && (argc != 5),
"nombre de parametres incorrect\n",NULL);
3502 filename = argv[1+decalage];
3511 fprintf(stdout,
"\n >>>>>> DUMP DU FICHIER %s >>>>>>\n",filename);
3520 typ_con_param=argv[2 + decalage];
3522 if (! strcmp(typ_con_param,
"NODALE")) typ_con =
MED_NODAL;
3523 if (! strcmp(typ_con_param,
"DESCENDANTE")) typ_con =
MED_DESCENDING;
3525 mode_coo_param=argv[3 + decalage];
3532 "Le paramètre d'entrelacement doit être soit "
3533 "NO_INTERLACE|FULL_INTERLACE|LECTURE_EN_TETE_SEULEMENT",NULL);
3546 fprintf(stdout,
"- Il y a "IFORMAT" maillages dans ce fichier \n",nmaa);
3547 fprintf(stdout,
" Lequel voulez-vous lire (0 pour tous|1|2|3|...|n) ?\n");
3549 fprintf(stdout,
" Reponse : ");
3550 if (!scanf(
"%d",&numero)) fgets(_temp, 256, stdin) ;
3551 }
while ( (numero > nmaa) || (numero < 0) );
3553 fprintf(stdout,
"- Il n'y a pas de maillage dans ce fichier \n");
3557 numero = atoi(argv[4 + decalage]);
3558 EXIT_IF(numero > nmaa || numero < 0,
"ce numero de maillage n'existe pas", NULL);
3568 fprintf(stdout,
"\n(*****************************************************)\n");
3569 fprintf(stdout,
"(* INFORMATIONS GENERALES SUR LES MAILLAGES SUPPORT: *)\n");
3570 fprintf(stdout,
"(*****************************************************)\n");
3572 for (meshit=1;meshit <= nmaasup;++meshit) {
3576 maillage_description, &rep, nomcoo, unicoo);
3577 fprintf(stdout,
"\n(*******************************************)\n");
3578 fprintf(stdout,
"(******** Maillage support n°%2.2d/%2.2"MED_IFORMAT" : *******)\n",meshit,nmaasup);
3579 fprintf(stdout,
"(*******************************************)\n");
3581 fprintf(stdout,
"- Nom du maillage support : <<%s>>\n",nommaa);
3582 fprintf(stdout,
"- Dimension du maillage : "IFORMAT"\n",mdim);
3584 fprintf(stdout,
"- La dimension de l'espace est "IFORMAT" \n",edim);
3587 nomcoo,unicoo,&rep, &_nmodels, &_geotype_elst,&_geotypename_elst,
3636 firstmesh=numero;lastmesh=numero;
3638 firstmesh=1;lastmesh=nmaa;
3641 for (meshit=firstmesh;meshit<=lastmesh;++meshit) {
3644 maillage_description,&nstep,dtunit,nomcoo,unicoo,&rep);
3647 for (csit=1; csit <= nstep; ++csit) {
3650 EXIT_IF(ret < 0,
"lors de l'appel à MEDmeshComputationStepInfo",NULL);
3658 _bannerstr =
"(* MAILLAGE DE CALCUL |%s| n°%2.2d A L'ETAPE DE CALCUL (n°dt,n°it)="
3660 snprintf(_temp,
MAXBANNERLEN+1,_bannerstr,nommaa,meshit,numdt,numit,0,
"");
3661 _bannerlen =strlen(_temp);
3662 fprintf(stdout,
"\n(");
3663 for (i=0;i< _bannerlen-6; i++) fprintf(stdout,
"*");
3664 fprintf(stdout,
")\n%s(",_temp);
3665 for (i=0;i< _bannerlen-6; i++) fprintf(stdout,
"*");
3666 fprintf(stdout,
")\n");
3676 &_nmodels,&_geotype_elst,&_geotypename_elst,
3677 lecture_en_tete_seulement);
3680 nomcoo,unicoo,lecture_en_tete_seulement);
3685 _nmodels,_geotype_elst,_geotypename_elst,
3686 lecture_en_tete_seulement);
3688 free(_geotype_elst);
3689 free(_geotypename_elst);
3697 EXIT_IF(ret < 0,
"lors de la fermeture du fichier",argv[1 + decalage]);
3699 fprintf(stdout,
"\n >>>>>> FIN DU DUMP DU FICHIER %s >>>>>>\n",argv[1 + decalage]);
3701 return EXIT_SUCCESS;
void lecture_equivalence_maillage(med_idt fid, const char *const nommaa, med_int nequ)
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...
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_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_geometry_type MED23MESH_GET_FACE_GEOMETRY_TYPE[MED_N_FACE_FIXED_GEO+2]
const med_geometry_type *const typmai
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 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...
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)
#define MED_N_ENTITY_TYPES
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 séquence de calcul : numéro de pas d...
med_int lecture_nombre_faces_polygones(const med_idt fid, const char *const nommaa, const med_int numdt, const med_int numit)
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.
med_int lecture_nombre_famille(med_idt fid, const char *const nommaa)
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.
med_geometry_type MED23FIELD_GET_EDGE_GEOMETRY_TYPE[MED_N_EDGE_FIXED_GEO+2]
const char *const MED23MESH_GET_ENTITY_TYPENAME[MED_N_ENTITY_TYPES+2]
med_int lecture_nombre_equivalence(med_idt fid, const char *const nommaa)
MEDC_EXPORT med_int MEDnStructElement(const med_idt fid)
Cette routine renvoie le nombre de modèles d'éléments de structure.
med_geometry_type MED23FIELD_GET_CELL_GEOMETRY_TYPE[MED_N_CELL_FIXED_GEO+2]
#define MED_N_FACE_FIXED_GEO
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.
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)
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 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.
const char *const MED23FIELD_GET_FACE_GEOMETRY_TYPENAME[MED_N_FACE_FIXED_GEO+2]
MEDC_EXPORT med_int MEDnProfile(const med_idt fid)
Cette routine permet de lire le nombre de profil dans un fichier MED.
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...
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...
med_geometry_type MED23MESH_GET_EDGE_GEOMETRY_TYPE[MED_N_EDGE_FIXED_GEO+2]
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_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 séquence de calc...
#define MED_N_CELL_FIXED_GEO
void lecture_localisation(med_idt fid, const med_switch_mode mode_coo, int lecture_en_tete_seulement)
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 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...
const med_geometry_type *const typfac
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 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...
#define MED_ERR_GEOMETRIC_MSG
med_entity_type MED23FIELD_GET_ENTITY_TYPE[MED_N_ENTITY_TYPES+2]
#define ISCRUTE_int(entier)
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...
void lecture_profils(med_idt fid, int lecture_en_tete_seulement)
#define MED_ALL_CONSTITUENT
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.
const med_geometry_type *const typare
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_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 séquence de calcul...
#define MED_N_EDGE_GEO_FIXED_CON
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)
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...
void lecture_famille_maillage(med_idt fid, const char *const nommaa, med_int nfam)
const char *const MED23MESH_GET_FACE_GEOMETRY_TYPENAME[MED_N_FACE_FIXED_GEO+2]
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_int MEDnLink(const med_idt fid)
Cette routine permet la lecture du nombre de lien dans un fichier MED.
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 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_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_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 séquence de ...
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 séquence de calcul du paramètre numé...
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)
int main(int argc, char **argv)
void lecture_modeles_elstruct(med_idt fid, int lecture_en_tete_seulement)
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 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.
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)
void lecture_liens(med_idt fid, int lecture_en_tete_seulement)
#define MED_ERR_RANGE_MSG
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.
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)
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...
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)
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.
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)
#define MED_N_EDGE_FIXED_GEO
void lecture_joint_maillage(med_idt fid, const char *const nommaa, med_int njnt)
MEDC_EXPORT med_int MEDnInterp(const med_idt fid)
Cette routine renvoie le nombre d'interpolations disponibles dans le fichier.
void lecture_parametres_scalaires(med_idt fid, int lecture_en_tete_seulement)
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 _MEDgetInternalGeometryTypeName(char *const geotypename, med_geometry_type geotype)
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 séquence de calcul d'un maillage...
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 MEDfieldnComponent(const med_idt fid, const int ind)
Cette fonction lit le nombre de composantes d'un champ.
MEDC_EXPORT med_int MEDnMesh(const med_idt fid)
Cette routine permet de lire le nombre de maillages dans un fichier.
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.
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_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 *const MED23MESH_GET_CELL_GEOMETRY_TYPENAME[MED_N_CELL_FIXED_GEO+2]
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 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_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 int MEDstructElementAttSizeof(med_attribute_type atttype)
Cette routine renvoie la taille en octets du type élémentaire atttype.
#define MED_N_CELL_GEO_FIXED_CON
MEDC_EXPORT med_int MEDnSupportMesh(const med_idt fid)
Cette routine permet de lire le nombre de maillages support dans un fichier.
const char *const MED23FIELD_GET_ENTITY_TYPENAME[MED_N_ENTITY_TYPES+2]
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_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 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 MEDfileClose(med_idt fid)
Fermeture d'un fichier MED.
const char * MED23MESH_GET_NODE_GEOMETRY_TYPENAME[MED_N_NODE_FIXED_GEO+2]
void affi(const void *pva)
_myfuncptr MEDstructPrintFunction(med_attribute_type atttype)
#define EXIT_IF(expression, message, arg)
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...
const char * MED23FIELD_GET_NODE_GEOMETRY_TYPENAME[MED_N_NODE_FIXED_GEO+2]
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_idt ouverture_fichier_MED(char *fichier)
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.
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)
void parametrage(med_switch_mode *mode_coo, med_connectivity_mode *typ_con)
med_geometry_type MED23FIELD_GET_FACE_GEOMETRY_TYPE[MED_N_FACE_FIXED_GEO+2]
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)
#define MED_N_FACE_GEO_FIXED_CON
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)
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)
const char *const MED23FIELD_GET_CELL_GEOMETRY_TYPENAME[MED_N_CELL_FIXED_GEO+2]
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)
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_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...
#define MED_N_NODE_FIXED_GEO
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)
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 séquence de c...
#define MED_LECTURE_ENTETE_SEULEMENT
const char *const * nomare
const char * MED23MESH_GET_EDGE_GEOMETRY_TYPENAME[MED_N_EDGE_FIXED_GEO+2]
const char *const * nomfac
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 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_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_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_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...
void lecture_fonctions_interpolation(med_idt fid, int lecture_en_tete_seulement)
med_geometry_type MED23MESH_GET_CELL_GEOMETRY_TYPE[MED_N_CELL_FIXED_GEO+2]
med_entity_type MED23MESH_GET_ENTITY_TYPE[MED_N_ENTITY_TYPES+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)
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 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 séquence de calcul do...
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...
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)
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.
med_geometry_type MED23FIELD_GET_NODE_GEOMETRY_TYPE[MED_N_NODE_FIXED_GEO+2]
const char * MED23FIELD_GET_EDGE_GEOMETRY_TYPENAME[MED_N_EDGE_FIXED_GEO+2]
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...
void affs(const void *pva)
void lecture_en_tete(med_idt fid, char *fichier)
med_geometry_type MED23MESH_GET_NODE_GEOMETRY_TYPE[MED_N_NODE_FIXED_GEO+2]
med_int lecture_nombre_joint(med_idt fid, const char *const nommaa)
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)
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.
void affd(const void *pva)
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_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.
void(* _myfuncptr)(const void *)
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 séquence de calcul...
const char *const * nommai
med_int lecture_nombre_noeuds_maillage_non_structure(const med_idt fid, const char *nommaa, const med_int numdt, const med_int numit)
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.
#define MED_LECTURE_MAILLAGE_SUPPORT_UNIQUEMENT
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 séquence de calcul donnée...
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, selon une séquence de calcul donnée.
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.