/**************************************************************************** * COPYRIGHT (C) 1999 - 2003 EDF R&D * THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY * IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE * AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; * EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION. * * THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT * WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU * LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. * * YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE * ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, * INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA * ******************************************************************************/ /****************************************************************************** * - Nom du fichier : mdump.c * * - Description : utilitaire de dump pour fichier MED V2.2 * Ce fichier contient les fonctions suivantes * qui constituent des modeles de programmation * pour une lecture generique d'un fichier MED V2.2 : * - lecture_maillage_non_structure () : * 1. Noeuds. * 2. Mailles : * - APPORT V2.2 : polyedres et polygones. * 3. Faces (connectivite descendante) : * - APPORT V2.2 : polygones. * 4. Aretes (connectivite descendante). * 5. Familles. * 6. Equivalences. * 7. Joints. * - lecture_maillage_structure () : (APPORT V2.2) * 1. Grille cartesienne | polaire | destructuree * 2. Familles de noeuds. * - lecture_resultats () : * 1. Champs de resultats relatifs à un maillage. * - Entites : * - Noeuds * - Mailles * - Faces * - Aretes * - Gestion des pas de temps et numeros d'ordre : * - APPORT V2.2 : stockage des valeurs * associees a plusieurs maillages sous * un meme pas de temps. * - Gestion des profils. * - Gestion des liens vers des maillages distants * - APPORT V2.2. * - Gestion des points de Gauss : * - APPORT V2.2.: localisation des * points de Gauss. * - lecture_parametres_scalaires () : (APPORT V2.2) * - Valeurs scalaires entieres ou flottantes. * - Gestion des pas de temps et numeros d'ordre. * - main() : infos generales + lecture de tous les champs et * du fichier MED passe en parametre. * *****************************************************************************/ #include <med.h> #include <med_utils.h> #include <stdio.h> #include <string.h> #include <stdlib.h> #define USER_MODE MED_COMPACT /****************************************************************************** * * - Nom de la fonction : lecture_maillage_non_structure * - Description : lecture et affichage d'un maillage MED_NON_STRUCTURE. * - Parametres : * - fid (IN) : ID du fichier MED. * - nommaa (IN) : nom du maillage a lire. * - mdim (IN) : dimension du maillage. * - mode_coo (IN) : mode de stockage en memoire : * MED_FULL_INTERLACE | MED_NO_INTERLACE. * - typ_con (IN) : mode de connectivite : * MED_FULL_INTERLACE | MED_NO_INTERLACE. * - lecture_en_tete_seulement (IN) : mode de lecture. * ******************************************************************************/ /* nombre de mailles concernees par les equivalences */ #define NBR_MAILLE_EQU 7 void lecture_maillage_non_structure(med_idt fid,char *nommaa,med_int mdim, med_mode_switch mode_coo, med_connectivite typ_con, int lecture_en_tete_seulement) { med_err ret = 0; int i,j,k,l; /* nombre d'objets MED */ med_int nnoe; med_int nmai[MED_NBR_GEOMETRIE_MAILLE],nfac[MED_NBR_GEOMETRIE_FACE]; med_int nare[MED_NBR_GEOMETRIE_ARETE]; /* noeuds */ med_float *coo; char nomcoo[3*MED_TAILLE_PNOM+1]; char unicoo[3*MED_TAILLE_PNOM+1]; char *nomnoe; med_int *numnoe; med_int *nufano; med_repere rep; med_booleen inonoe,inunoe; char str[MED_TAILLE_PNOM+1]; /* elements */ med_int edim; med_int taille; med_int *connectivite; char *nomele; med_int *numele; med_int *nufael; med_booleen inoele, inuele; med_geometrie_element typgeo; med_geometrie_element typmai[MED_NBR_GEOMETRIE_MAILLE] = {MED_POINT1,MED_SEG2, MED_SEG3,MED_TRIA3, MED_TRIA6,MED_QUAD4, MED_QUAD8,MED_TETRA4, MED_TETRA10,MED_HEXA8, MED_HEXA20,MED_PENTA6, MED_PENTA15,MED_PYRA5, MED_PYRA13}; med_int desmai[MED_NBR_GEOMETRIE_MAILLE] = {0,2,3,3,3,4,4,4,4,6,6,5,5,5,5}; med_int nmailles[MED_NBR_GEOMETRIE_MAILLE]; char nommai[MED_NBR_GEOMETRIE_MAILLE] [MED_TAILLE_NOM+1] = {"MED_POINT1", "MED_SEG2", "MED_SEG3", "MED_TRIA3", "MED_TRIA6", "MED_QUAD4", "MED_QUAD8", "MED_TETRA4", "MED_TETRA10", "MED_HEXA8", "MED_HEXA20", "MED_PENTA6", "MED_PENTA15", "MED_PYRA5", "MED_PYRA13"}; med_geometrie_element typfac[MED_NBR_GEOMETRIE_FACE] = {MED_TRIA3,MED_TRIA6, MED_QUAD4,MED_QUAD8}; med_int desfac[MED_NBR_GEOMETRIE_FACE] = {3,3,4,4}; med_int nfaces[MED_NBR_GEOMETRIE_FACE]; char nomfac[MED_NBR_GEOMETRIE_FACE][MED_TAILLE_NOM+1] = {"MED_TRIA3", "MED_TRIA6", "MED_QUAD4", "MED_QUAD8"}; med_geometrie_element typare[MED_NBR_GEOMETRIE_ARETE] = {MED_SEG2, MED_SEG3}; med_int desare[MED_NBR_GEOMETRIE_ARETE] = {2,3}; med_int naretes[MED_NBR_GEOMETRIE_ARETE]; char nomare[MED_NBR_GEOMETRIE_ARETE] [MED_TAILLE_NOM+1] = {"MED_SEG2", "MED_SEG3"}; /* familles */ med_int nfam; med_int natt,ngro; char *attdes,*gro; med_int *attval,*attide; char nomfam[MED_TAILLE_NOM+1]; med_int numfam; char str1[MED_TAILLE_DESC+1]; char str2[MED_TAILLE_LNOM+1]; /* equivalences */ med_int nequ,ncor; med_int *cor; char equ[MED_TAILLE_NOM+1]; char des[MED_TAILLE_DESC+1]; /* joints */ med_int njnt,ndom,nc,nent; med_int typ_ent_local,typ_geo_local,typ_ent_distant,typ_geo_distant; med_int geo_ent_local,geo_ent_distant; char jn[MED_TAILLE_NOM+1]; char maa_dist[MED_TAILLE_NOM+1]; char corr[MED_TAILLE_NOM+1]; med_int *cortab; const med_int nb_geo_ent=1+MED_NBR_GEOMETRIE_MAILLE+MED_NBR_GEOMETRIE_ARETE+MED_NBR_GEOMETRIE_FACE; med_geometrie_element typ_geo_ent[1+MED_NBR_GEOMETRIE_MAILLE+MED_NBR_GEOMETRIE_ARETE+MED_NBR_GEOMETRIE_FACE][2]= { {MED_NOEUD,0}, {MED_MAILLE,MED_POINT1 }, {MED_MAILLE,MED_SEG2 }, {MED_MAILLE,MED_SEG3 }, {MED_MAILLE,MED_TRIA3 }, {MED_MAILLE,MED_TRIA6 }, {MED_MAILLE,MED_QUAD4 }, {MED_MAILLE,MED_QUAD8 }, {MED_MAILLE,MED_TETRA4 }, {MED_MAILLE,MED_TETRA10 }, {MED_MAILLE,MED_HEXA8 }, {MED_MAILLE,MED_HEXA20 }, {MED_MAILLE,MED_PENTA6 }, {MED_MAILLE,MED_PENTA15 }, {MED_MAILLE,MED_PYRA5 }, {MED_MAILLE,MED_PYRA13 }, {MED_ARETE ,MED_SEG2 }, {MED_ARETE ,MED_SEG3 }, {MED_FACE ,MED_TRIA3 }, {MED_FACE ,MED_TRIA6 }, {MED_FACE ,MED_QUAD4 }, {MED_FACE ,MED_QUAD8 } }; char nom_geo_ent[1+MED_NBR_GEOMETRIE_MAILLE+MED_NBR_GEOMETRIE_ARETE+MED_NBR_GEOMETRIE_FACE][MED_TAILLE_NOM+1] = { "MED_NOEUD ", "MED_MAILLE:MED_POINT1 ", "MED_MAILLE:MED_SEG2 ", "MED_MAILLE:MED_SEG3 ", "MED_MAILLE:MED_TRIA3 ", "MED_MAILLE:MED_TRIA6 ", "MED_MAILLE:MED_QUAD4 ", "MED_MAILLE:MED_QUAD8 ", "MED_MAILLE:MED_TETRA4 ", "MED_MAILLE:MED_TETRA10 ", "MED_MAILLE:MED_HEXA8 ", "MED_MAILLE:MED_HEXA20 ", "MED_MAILLE:MED_PENTA6 ", "MED_MAILLE:MED_PENTA15 ", "MED_MAILLE:MED_PYRA5 ", "MED_MAILLE:MED_PYRA13 ", "MED_ARETE :MED_SEG2 ", "MED_ARETE :MED_SEG3 ", "MED_FACE :MED_TRIA3 ", "MED_FACE :MED_TRIA6 ", "MED_FACE :MED_QUAD4 ", "med_FACE :MED_QUAD8 " }; /* mailles/faces MED_POLYGONE et MED_POLYEDRE */ med_int nmpolygones,nfpolygones,npolyedres; med_int *indexp, *indexf; int ind1,ind2,np; med_int nf; char tmp[MED_TAILLE_NOM+1]; med_err ret1,ret2,ret3; med_int nfa; /* Combien de noeuds ? */ nnoe = MEDnEntMaa(fid,nommaa,MED_COOR,MED_NOEUD,0,0); EXIT_IF(nnoe < 0,"lors de la lecture du nombre de noeuds",NULL); fprintf(stdout,"- Nombre de noeuds : %d \n",nnoe); /* Combien de mailles, faces ou aretes ? */ for (i=0;i<MED_NBR_GEOMETRIE_MAILLE;i++) { nmailles[i] = MEDnEntMaa(fid,nommaa,MED_CONN,MED_MAILLE,typmai[i], typ_con); EXIT_IF(nmailles[i] < 0," lors de la lecture du nombre de mailles",NULL); fprintf (stdout,"- Nombre de mailles de type %s : %d \n",nommai[i],nmailles[i]); } /* Combien de mailles polygones ? */ nmpolygones = MEDnEntMaa(fid,nommaa,MED_CONN,MED_MAILLE,MED_POLYGONE, typ_con); EXIT_IF(nmpolygones < 0,"lors de la lecture du nombre de mailles polygone \n", NULL); fprintf(stdout,"- Nombre de mailles de type MED_POLYGONE : %d \n",nmpolygones); /* Combien de mailles polyedres ? */ npolyedres = MEDnEntMaa(fid,nommaa,MED_CONN,MED_MAILLE,MED_POLYEDRE, typ_con); EXIT_IF(npolyedres < 0,"lors de la lecture du nombre de mailles polyedre \n", NULL); fprintf(stdout,"- Nombre de mailles de type MED_POLYEDRE : %d \n",npolyedres); /* Combien de faces ? */ for (i=0;i<MED_NBR_GEOMETRIE_FACE;i++) { nfaces[i] = MEDnEntMaa(fid,nommaa,MED_CONN,MED_FACE,typfac[i], typ_con); EXIT_IF(nfaces[i] < 0,"lors de la lecture du nombre de faces",NULL); fprintf (stdout,"- Nombre de faces de type %s : %d \n",nomfac[i],nfaces[i]); } /* Combien de faces polygones ? */ nfpolygones = MEDnEntMaa(fid,nommaa,MED_CONN,MED_FACE,MED_POLYGONE, typ_con); EXIT_IF(nfpolygones < 0,"lors de la lecture du nombre de faces polygone \n", NULL); fprintf(stdout,"- Nombre de faces de type MED_POLYGONE : %d \n",nfpolygones); /* Combien d'aretes */ for (i=0;i<MED_NBR_GEOMETRIE_ARETE;i++) { naretes[i] = MEDnEntMaa(fid,nommaa,MED_CONN,MED_ARETE,typare[i], typ_con); EXIT_IF(naretes[i] < 0,"lors de la lecture du nombre d'aretes",NULL); fprintf (stdout,"- Nombre d'aretes de type %s : %d \n",nomare[i],naretes[i]); } /* nombre de familles */ nfam = MEDnFam(fid,nommaa); EXIT_IF(nfam < 0,"lors de la lecture du nombre de familles",NULL); fprintf(stdout,"- Nombre de familles : %d \n",nfam); /* combien d'equivalences dans le fichier */ nequ = MEDnEquiv(fid,nommaa); EXIT_IF(nequ < 0,"lors de la lecture du nombre d'equivalences",NULL); fprintf(stdout,"- Nombre d'equivalences : %d \n",nequ); /* combien de joints dans le fichier */ njnt = MEDnJoint(fid,nommaa); EXIT_IF(njnt < 0,"lors de la lecture du nombre de joints",NULL); fprintf(stdout,"- Nombre de joints : %d \n",njnt); /* en fonction du mode de lecture, on continue ou non */ if (lecture_en_tete_seulement) return; /**************************************************************************** * LECTURE DES NOEUDS * ****************************************************************************/ /* Allocations memoires */ /* table des coordonnees profil : (dimension * nombre de noeuds ) */ coo = (med_float*) malloc(sizeof(med_float)*nnoe*mdim); EXIT_IF(coo == NULL,NULL,NULL); /* table des numeros, des numeros de familles des noeuds profil : (nombre de noeuds) */ numnoe = (med_int*) malloc(sizeof(med_int)*nnoe); EXIT_IF(numnoe == NULL,NULL,NULL); nufano = (med_int*) malloc(sizeof(med_int)*nnoe); EXIT_IF(nufano == NULL,NULL,NULL); /* table des noms des noeuds profil : (nnoe*MED_TAILLE_PNOM+1) */ nomnoe = (char*) malloc(MED_TAILLE_PNOM*nnoe+1); EXIT_IF(nomnoe == NULL,NULL,NULL); /* lecture des noeuds : - coordonnees - noms (optionnel dans un fichier MED) - numeros (optionnel dans un fichier MED) - numeros des familles */ ret = MEDnoeudsLire(fid,nommaa,mdim,coo,mode_coo,&rep, nomcoo,unicoo,nomnoe,&inonoe,numnoe,&inunoe, nufano,nnoe); EXIT_IF(ret < 0,"lors de la lecture des noeuds du maillage \n",NULL); /* affichage des resultats */ fprintf(stdout,"\n(************************)\n"); fprintf(stdout,"(* NOEUDS DU MAILLAGE : *)\n"); fprintf(stdout,"(************************)\n"); fprintf(stdout,"- Type de repere des coordonnees : %d \n",rep); fprintf(stdout,"- Nom des coordonnees : \n"); for (i=0;i<mdim;i++) { strncpy(str,nomcoo+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM); str[MED_TAILLE_PNOM] = '\0'; fprintf(stdout," %s ",str); } fprintf(stdout,"\n- Unites des coordonnees : \n"); for (i=0;i<mdim;i++) { strncpy(str,unicoo+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM); str[MED_TAILLE_PNOM] = '\0'; fprintf(stdout," %s ",str); } fprintf(stdout,"\n- Coordonnees des noeuds : \n"); for (i=0;i<nnoe*mdim;i++) fprintf(stdout," %f ",*(coo+i)); if (inonoe) { fprintf(stdout,"\n- Noms des noeuds : \n"); for (i=0;i<nnoe;i++) { strncpy(str,nomnoe+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM); str[MED_TAILLE_PNOM] = '\0'; fprintf(stdout," %s ",str); } } if (inunoe) { fprintf(stdout,"\n- Numeros des noeuds : \n"); for (i=0;i<nnoe;i++) fprintf(stdout," %d ",*(numnoe+i)); } fprintf(stdout,"\n- Numeros des familles des noeuds : \n"); for (i=0;i<nnoe;i++) fprintf(stdout," %d ",*(nufano+i)); fprintf(stdout,"\n"); /* liberation memoire */ free(coo); free(nomnoe); free(numnoe); free(nufano); /**************************************************************************** * LECTURE DES ELEMENTS * ****************************************************************************/ fprintf(stdout,"\n(**************************)\n"); fprintf(stdout,"(* ELEMENTS DU MAILLAGE : *)\n"); fprintf(stdout,"(**************************)"); /* Lecture des connectivites, noms, numeros des mailles */ for (i=0;i<MED_NBR_GEOMETRIE_MAILLE;i++) if (nmailles[i] > 0) { /* dimension de la maille */ edim = typmai[i] / 100; switch(typ_con) { case MED_NOD : taille = typmai[i]%100; break; case MED_DESC : taille = desmai[i]; break; default : ret = -1; } /* allocation memoire */ connectivite = (med_int*)malloc(sizeof(med_int)*taille*nmailles[i]); EXIT_IF(connectivite == NULL,NULL,NULL); nomele = (char*)malloc(sizeof(char)*MED_TAILLE_PNOM*nmailles[i]+1); EXIT_IF(nomele == NULL,NULL,NULL); numele = (med_int*)malloc(sizeof(med_int)*nmailles[i]); EXIT_IF(numele == NULL,NULL,NULL); nufael = (med_int*)malloc(sizeof(med_int)*nmailles[i]); EXIT_IF(nufael == NULL,NULL,NULL); /* lecture des données */ ret = MEDelementsLire(fid,nommaa,mdim,connectivite,mode_coo, nomele,&inoele,numele,&inuele,nufael, nmailles[i],MED_MAILLE,typmai[i], typ_con); EXIT_IF(ret < 0,"lors de la lecture des mailles (conncetivite,numeros,noms et numeros de famille", NULL); /* affichage des resultats */ fprintf(stdout,"\n\n- Mailles de type %s : ", nommai[i]); fprintf(stdout,"\n - Connectivité : \n"); for (j=0;j<nmailles[i]*taille;j++) fprintf(stdout," %d ",*(connectivite+j)); if (inoele) { fprintf(stdout,"\n - Noms : \n"); for (j=0;j<nmailles[i];j++) { strncpy(str,nomele+j*MED_TAILLE_PNOM,MED_TAILLE_PNOM); str[MED_TAILLE_PNOM] = '\0'; fprintf(stdout," %s ",str); } } if (inuele) { fprintf(stdout,"\n - Numeros :\n"); for (j=0;j<nmailles[i];j++) fprintf(stdout," %d ",*(numele+j)); } fprintf(stdout,"\n - Numéros de familles : \n"); for (j=0;j<nmailles[i];j++) fprintf(stdout," %d ",*(nufael+j)); /* liberation memoire */ free(connectivite); free(nomele); free(numele); free(nufael); } /* lecture des mailles de type MED_POLYGONE */ if (nmpolygones > 0) { /* quelle taille pour le tableau des connectivites ? */ ret = MEDpolygoneInfo(fid,nommaa,MED_MAILLE,typ_con,&taille); EXIT_IF(ret < 0,"lors de la lecture des parametres des mailles MED_POLYGONE",NULL); /* allocation memoire */ indexp = (med_int *) malloc(sizeof(med_int)*(nmpolygones+1)); EXIT_IF(indexp == NULL,NULL,NULL); connectivite = (med_int *) malloc(sizeof(med_int)*taille); EXIT_IF(connectivite == NULL,NULL,NULL); numele = (med_int *) malloc(sizeof(med_int)*nmpolygones); EXIT_IF(numele == NULL,NULL,NULL); nufael = (med_int *) malloc(sizeof(med_int)*nmpolygones); EXIT_IF(nufael == NULL,NULL,NULL); nomele = (char *) malloc(sizeof(char)*MED_TAILLE_PNOM*nmpolygones+1); EXIT_IF(nomele == NULL,NULL,NULL); /* lecture de la connectivite des mailles polygones */ ret = MEDpolygoneConnLire(fid,nommaa,indexp,nmpolygones+1,connectivite, MED_MAILLE,typ_con); EXIT_IF(ret < 0,"lors de la lecture des connectivites des mailles de type MED_POLYGONE",NULL); /* lecture noms */ ret1 = MEDnomLire(fid,nommaa,nomele,nmpolygones,MED_MAILLE,MED_POLYGONE); /* lecture des numeros */ ret2 = (med_int) MEDnumLire(fid,nommaa,numele,nmpolygones, MED_MAILLE,MED_POLYGONE); /* lecture des numeros de familles */ ret3 = MEDfamLire(fid,nommaa,nufael,nmpolygones,MED_MAILLE,MED_POLYGONE); if (ret3 < 0) for (i=0;i<nmpolygones;i++) *(nufael+i) = 0; /* affichage des resultats */ fprintf(stdout,"\n\n- Mailles de type MED_POLYGONE : "); for (i=0;i<nmpolygones;i++) { fprintf(stdout,"\n >> Maille MED_POLYGONE %d : \n",i+1); fprintf(stdout,"\n - Connectivité : "); ind1 = *(indexp+i)-1; ind2 = *(indexp+i+1)-1; for (j=ind1;j<ind2;j++) printf(" %d ",*(connectivite+j)); if (ret1 == 0) { strncpy(tmp,nomele+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM); tmp[MED_TAILLE_PNOM] = '\0'; fprintf(stdout,"\n - Nom : %s \n",tmp); } if (ret2 == 0) fprintf(stdout,"\n - Numero : %d \n",*(numele+i)); fprintf(stdout,"\n - Numéro de famille : %d \n",*(nufael+i)); } /* on libere la memoire */ free(indexp); free(connectivite); free(numele); free(nufael); free(nomele); } /* lecture des mailles de type MED_POLYEDRE */ if (npolyedres > 0) { /* lecture des parametres de base */ ret = MEDpolyedreInfo(fid,nommaa,typ_con,&nf,&taille); EXIT_IF(ret < 0,"lors de la lecture des parametres des mailles MED_POLYEDRE",NULL); /* allocation memoire */ indexp = (med_int *) malloc(sizeof(med_int)*(npolyedres+1)); EXIT_IF(indexp == NULL,NULL,NULL); indexf = (med_int *) malloc(sizeof(med_int)*nf); EXIT_IF(indexf == NULL,NULL,NULL); connectivite = (med_int *) malloc(sizeof(med_int)*taille); EXIT_IF(connectivite == NULL,NULL,NULL); numele = (med_int *) malloc(sizeof(med_int)*npolyedres); EXIT_IF(numele == NULL,NULL,NULL); nufael = (med_int *) malloc(sizeof(med_int)*npolyedres); EXIT_IF(nufael == NULL,NULL,NULL); nomele = (char *) malloc(sizeof(char)*MED_TAILLE_PNOM*npolyedres+1); EXIT_IF(nomele == NULL,NULL,NULL); /* lecture de la connectivite des mailles polyedres */ ret = MEDpolyedreConnLire(fid,nommaa,indexp,npolyedres+1,indexf,nf, connectivite,MED_NOD); EXIT_IF(ret < 0,"lors de la lecture de la connectivite des mailles MED_POLYEDRES", NULL); /* lecture des noms */ ret1 = MEDnomLire(fid,nommaa,nomele,npolyedres,MED_MAILLE,MED_POLYEDRE); /* lecture des numeros */ ret2 = MEDnumLire(fid,nommaa,numele,npolyedres,MED_MAILLE,MED_POLYEDRE); /* lecture des numeros de familles */ ret3 = MEDfamLire(fid,nommaa,nufael,npolyedres,MED_MAILLE,MED_POLYEDRE); if (ret3 < 0) for (i=0;i<npolyedres;i++) *(nufael+i) = 0; /* affichage des resultats */ fprintf(stdout,"\n\n- Mailles de type MED_POLYEDRE : "); for (i=0;i<npolyedres;i++) { fprintf(stdout,"\n >> Maille MED_POLYEDRE %d : \n",i+1); fprintf(stdout,"\n - Connectivité : \n"); nfa = *(indexp+i+1) - *(indexp+i); /* ind1 = indice dans "indexf" pour acceder aux numeros des faces */ ind1 = *(indexp+i) - 1; for (j=0;j<nfa;j++) { if (typ_con == MED_NOD) { /* ind2 = indice dans "connectivite" pour acceder au premier noeud de la face */ ind2 = *(indexf+ind1+j) - 1; nnoe = *(indexf+ind1+j+1) - *(indexf+ind1+j); fprintf(stdout," - Face %d : [ ", j+1); for (k=0;k<nnoe;k++) printf(" %d ",*(connectivite+ind2+k)); printf(" ] \n"); } else { nfa = *(indexp+i+1) - *(indexp+i); /* ind1 = indice dans "connectivite" pour acceder aux numeros des faces */ ind1 = *(indexp+i) - 1; for (j=0;j<nfa;j++) fprintf(stdout," - Face %d de numero : %d et de type %d \n", j+1, *(connectivite+ind1+j),*(indexf+ind1+j)); } } if (ret1 == 0) { strncpy(tmp,nomele+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM); tmp[MED_TAILLE_PNOM] = '\0'; fprintf(stdout,"\n - Nom : %s \n",tmp); } if (ret2 == 0) fprintf(stdout,"\n - Numero : %d \n",*(numele+i)); fprintf(stdout,"\n - Numéro de famille : %d \n",*(nufael+i)); } /* on libere la memoire */ free(indexp); free(indexf); free(connectivite); free(numele); free(nufael); free(nomele); } /* lecture des faces */ if (typ_con == MED_DESC) for (i=0;i<MED_NBR_GEOMETRIE_FACE;i++) if (nfaces[i] > 0 ) { /* dimension de la face */ edim = typfac[i] / 100; switch(typ_con) { case MED_NOD : taille = typfac[i]%100; break; case MED_DESC : taille = desfac[i]; break; default : ret = -1; } /* allocation memoire */ connectivite = (med_int*)malloc(sizeof(med_int)*taille*nfaces[i]); EXIT_IF(connectivite == NULL,NULL,NULL); nomele = (char*)malloc(sizeof(char)*MED_TAILLE_PNOM*nfaces[i]+1); EXIT_IF(nomele == NULL,NULL,NULL); numele = (med_int*)malloc(sizeof(med_int)*nfaces[i]); EXIT_IF(numele == NULL,NULL,NULL); nufael = (med_int*)malloc(sizeof(med_int)*nfaces[i]); EXIT_IF(nufael == NULL,NULL,NULL); /* lecture des données */ ret = MEDelementsLire(fid,nommaa,mdim,connectivite,mode_coo, nomele,&inoele,numele,&inuele,nufael, nfaces[i],MED_FACE,typfac[i], typ_con); EXIT_IF(ret < 0,"lors de la lecture des faces (connectivite,noms,numeros,numeros de familles)", NULL); /* affichage des resultats */ fprintf(stdout,"\n- Faces de type %s : ", nomfac[i]); fprintf(stdout,"\n - Connectivité : \n"); for (j=0;j<nfaces[i]*taille;j++) fprintf(stdout," %d ",*(connectivite+j)); if (inoele) { fprintf(stdout,"\n - Noms : \n"); for (j=0;j<nfaces[i];j++) { fprintf(stdout," %d ",*(connectivite+j)); strncpy(str,nomele+j*MED_TAILLE_PNOM,MED_TAILLE_PNOM); str[MED_TAILLE_PNOM] = '\0'; fprintf(stdout," %s ",str); } } if (inuele) { fprintf(stdout,"\n - Numeros :\n"); for (j=0;j<nfaces[i];j++) fprintf(stdout," %d ",*(numele+j)); } fprintf(stdout,"\n - Numéros de familles : \n"); for (j=0;j<nfaces[i];j++) fprintf(stdout," %d ",*(nufael+j)); /* liberation memoire */ free(connectivite); free(nomele); free(numele); free(nufael); } /* lecture des faces de type MED_POLYGONE */ if (nfpolygones > 0 && typ_con == MED_DESC) { /* quelle taille pour le tableau des connectivites ? */ ret = MEDpolygoneInfo(fid,nommaa,MED_FACE,typ_con,&taille); EXIT_IF(ret < 0,"lors de la lecture des parametres des faces MED_POLYGONE",NULL); /* allocation memoire */ indexp = (med_int *) malloc(sizeof(med_int)*(nfpolygones+1)); EXIT_IF(indexp == NULL,NULL,NULL); connectivite = (med_int *) malloc(sizeof(med_int)*taille); EXIT_IF(connectivite == NULL,NULL,NULL); numele = (med_int *) malloc(sizeof(med_int)*nfpolygones); EXIT_IF(numele == NULL,NULL,NULL); nufael = (med_int *) malloc(sizeof(med_int)*nfpolygones); EXIT_IF(nufael == NULL,NULL,NULL); nomele = (char *) malloc(sizeof(char)*MED_TAILLE_PNOM*nfpolygones+1); EXIT_IF(nomele == NULL,NULL,NULL); /* lecture de la connectivite des faces polygones */ ret = MEDpolygoneConnLire(fid,nommaa,indexp,nfpolygones+1,connectivite, MED_FACE,typ_con); EXIT_IF(ret < 0,"lors de la lecture des connectivites des faces de type MED_POLYGONE",NULL); /* lecture noms */ ret1 = MEDnomLire(fid,nommaa,nomele,nfpolygones,MED_FACE,MED_POLYGONE); /* lecture des numeros */ ret2 = (med_int) MEDnumLire(fid,nommaa,numele,nfpolygones, MED_FACE,MED_POLYGONE); /* lecture des numeros de familles */ ret3 = MEDfamLire(fid,nommaa,nufael,nfpolygones,MED_FACE,MED_POLYGONE); if (ret3 < 0) for (i=0;i<nfpolygones;i++) *(nufael+i) = 0; /* affichage des resultats */ fprintf(stdout,"\n\n- Faces de type MED_POLYGONE : "); for (i=0;i<nfpolygones;i++) { fprintf(stdout,"\n >> Face MED_POLYGONE %d : \n",i+1); fprintf(stdout,"\n - Connectivité : "); ind1 = *(indexp+i)-1; ind2 = *(indexp+i+1)-1; for (j=ind1;j<ind2;j++) fprintf(stdout," %d ",*(connectivite+j)); if (ret1 == 0) { strncpy(tmp,nomele+j*MED_TAILLE_PNOM,MED_TAILLE_PNOM); tmp[MED_TAILLE_PNOM] = '\0'; fprintf(stdout,"\n - Nom : %s \n",tmp); } if (ret2 == 0) fprintf(stdout,"\n - Numero : %d \n",*(numele+j)); fprintf(stdout,"\n - Numéro de famille : %d \n",*(nufael+j)); } /* on libere la memoire */ free(indexp); free(connectivite); free(numele); free(nufael); free(nomele); } /* les aretes */ if (typ_con == MED_DESC) for (i=0;i<MED_NBR_GEOMETRIE_ARETE;i++) if (naretes[i] > 0) { /* dimension de l'arete */ edim = typare[i] / 100; switch(typ_con) { case MED_NOD : taille = typare[i]%100; break; case MED_DESC : taille = desare[i]; break; default : ret = -1; } /* allocation memoire */ connectivite = (med_int*)malloc(sizeof(med_int)*taille*naretes[i]); EXIT_IF(connectivite == NULL,NULL,NULL); nomele = (char*)malloc(sizeof(char)*MED_TAILLE_PNOM*naretes[i]+1); EXIT_IF(nomele == NULL,NULL,NULL); numele = (med_int*)malloc(sizeof(med_int)*naretes[i]); EXIT_IF(numele == NULL,NULL,NULL); nufael = (med_int*)malloc(sizeof(med_int)*naretes[i]); EXIT_IF(nufael == NULL,NULL,NULL); /* lecture des données */ ret = MEDelementsLire(fid,nommaa,mdim,connectivite,mode_coo, nomele,&inoele,numele,&inuele,nufael, naretes[i],MED_ARETE,typare[i], typ_con); EXIT_IF(ret < 0,"lors de la lecture des aretes (connectivite,noms,numeros,numeros de familles)", NULL); /* affichage des resultats */ fprintf(stdout,"\n- Aretes de type %d : ", nomare[i]); fprintf(stdout,"\n - Connectivité : \n"); for (j=0;j<naretes[i]*taille;j++) fprintf(stdout," %d ",*(connectivite+j)); if (inoele) { fprintf(stdout,"\n - Noms : \n"); for (j=0;j<naretes[i];j++) { fprintf(stdout," %d ",*(connectivite+j)); strncpy(str,nomele+j*MED_TAILLE_PNOM,MED_TAILLE_PNOM); str[MED_TAILLE_PNOM] = '\0'; fprintf(stdout," %s ",str); } } if (inuele) { fprintf(stdout,"\n - Numeros :\n"); for (j=0;j<naretes[i];j++) fprintf(stdout," %d ",*(numele+j)); } fprintf(stdout,"\n - Numéros de familles : \n"); for (j=0;j<naretes[i];j++) fprintf(stdout," %d ",*(nufael+j)); /* liberation memoire */ free(connectivite); free(nomele); free(numele); free(nufael); } /**************************************************************************** * LECTURE DES FAMILLES * ****************************************************************************/ printf("\n(*************************)\n"); printf("(* FAMILLES DU MAILLAGE *)\n"); printf("(*************************)\n"); for (i=0;i<nfam;i++) { /* nombre de groupes */ ngro = MEDnGroupe(fid,nommaa,i+1); EXIT_IF(ngro < 0,"lors de la lecture du nombre de groupe d'une famille",NULL); /* nombre d'attributs */ natt = MEDnAttribut(fid,nommaa,i+1); EXIT_IF(natt < 0,"lors de la lecture du nombre d'attributs d'une famille",NULL); fprintf(stdout,"- Famille %d a %d attribut(s) et %d groupe(s) \n",i+1,natt,ngro); /* nom,numero,attributs,groupes */ /* allocation memoire */ if (natt > 0) { attide = (med_int*) malloc(sizeof(med_int)*natt); EXIT_IF(attide == NULL,NULL,NULL); attval = (med_int*) malloc(sizeof(med_int)*natt); EXIT_IF(attval == NULL,NULL,NULL); attdes = (char *) malloc(MED_TAILLE_DESC*natt+1); EXIT_IF(attdes == NULL,NULL,NULL); } else { attide = NULL; attval = NULL; attdes = NULL; } if (ngro > 0) { gro = (char*) malloc(MED_TAILLE_LNOM*ngro+1); EXIT_IF(gro == NULL,NULL,NULL); } else { gro = NULL; } ret = MEDfamInfo(fid,nommaa,i+1,nomfam,&numfam,attide,attval, attdes,&natt,gro,&ngro); EXIT_IF(ret < 0,"lors de la lecture des informations d'une famille", NULL); /* affichage des resultats */ fprintf(stdout," - Famille de nom %s et de numero %d : \n",nomfam,numfam); fprintf(stdout," - Attributs : \n"); for (j=0;j<natt;j++) { strncpy(str1,attdes+j*MED_TAILLE_DESC,MED_TAILLE_DESC); str1[MED_TAILLE_DESC] = '\0'; fprintf(stdout," identificateur = %d - valeur = %d - description = %s\n",*(attide+j), *(attval+j),str1); } free(attide); free(attval); free(attdes); fprintf(stdout," - Groupes :\n"); for (j=0;j<ngro;j++) { strncpy(str2,gro+j*MED_TAILLE_LNOM,MED_TAILLE_LNOM); str2[MED_TAILLE_LNOM] = '\0'; fprintf(stdout," groupe %d = %s\n",j+1,str2); } free(gro); } /**************************************************************************** * LECTURE DES EQUIVALENCES * ****************************************************************************/ fprintf(stdout,"\n(******************************)\n"); fprintf(stdout,"(* EQUIVALENCES DU MAILLAGE : *)\n"); fprintf(stdout,"(******************************)\n"); if (nequ == 0) fprintf(stdout,"- Aucune équivalence \n"); /* lecture de toutes les equivalences associes a nommaa */ for (i = 0;i<nequ;i++) { fprintf(stdout,"- Equivalence numero : %d ",i+1); /* lecture des infos sur l'equivalence */ ret = MEDequivInfo(fid,nommaa,i+1,equ,des); EXIT_IF(ret < 0,"lors de la lecture des informations sur une equivalence", NULL); fprintf(stdout,"\n - Nom de l'equivalence: %s \n",equ); fprintf(stdout,"\n - Description de l'equivalence : %s \n",des); /* lecture des correspondances sur les differents types d'entites */ /* les noeuds */ ncor = MEDnCorres(fid,nommaa,equ,MED_NOEUD,0); EXIT_IF(ncor < 0,"lors de la lecture du nombre de correspondances d'une equivalence", NULL); fprintf(stdout,"\n - Il y a %d correspondances sur les noeuds \n",ncor); if (ncor > 0) { /* allocation memoire */ cor = (med_int*) malloc(sizeof(med_int)*ncor*2); EXIT_IF(cor == NULL,NULL,NULL); ret = MEDequivLire(fid,nommaa,equ,cor,ncor,MED_NOEUD,0); EXIT_IF(ret < 0,"lors de la lecture du tableau des correspondances", NULL); for (j=0;j<ncor;j++) fprintf(stdout,"\n - Correspondance %d : %d et %d \n",j+1,*(cor+2*j), *(cor+2*j+1)); free(cor); } /* sur les mailles : on ne prend pas en compte les mailles 3D */ for (j=0;j<NBR_MAILLE_EQU;j++) { ncor = MEDnCorres(fid,nommaa,equ,MED_MAILLE,typmai[j]); EXIT_IF(ncor < 0,"lors de la lecture du nombre de correspondances dans une equivalence", NULL); fprintf(stdout,"\n - Il y a %d correspondances sur les mailles %s \n",ncor, nommai[j]); if (ncor > 0) { /* allocation memoire */ cor = (med_int*) malloc(sizeof(med_int)*ncor*2); EXIT_IF(cor == NULL,NULL,NULL); ret = MEDequivLire(fid,nommaa,equ,cor,ncor,MED_MAILLE, typmai[j]); EXIT_IF(ret < 0,"lors de la lecture du tableau des equivalences", NULL); for (k=0;k<ncor;k++) fprintf(stdout,"\n - Correspondance %d : %d et %d \n",k+1,*(cor+2*k), *(cor+2*k+1)); free(cor); } } /* sur les faces */ for (j=0;j<MED_NBR_GEOMETRIE_FACE;j++) { ncor = MEDnCorres(fid,nommaa,equ,MED_FACE,typfac[j]); EXIT_IF(ncor < 0,"lors de la lecture du nombre de correspondances dans une equivalence", NULL); fprintf(stdout,"\n - Il y a %d correspondances sur les faces %s\n",ncor, nomfac[j]); if (ncor > 0) { /* allocation memoire */ cor = (med_int*) malloc(sizeof(med_int)*ncor*2); EXIT_IF(cor == NULL,NULL,NULL); ret = MEDequivLire(fid,nommaa,equ,cor,ncor,MED_FACE, typfac[j]); EXIT_IF(ret < 0,"lors de la lecture du tableau des equivalences", NULL); for (k=0;k<ncor;k++) fprintf(stdout,"\n - Correspondance %d : %d et %d \n",k+1,*(cor+2*k), *(cor+2*k+1)); free(cor); } } /* sur les aretes */ for (j=0;j<MED_NBR_GEOMETRIE_ARETE;j++) { ncor = MEDnCorres(fid,nommaa,equ,MED_ARETE,typare[j]); EXIT_IF(ncor < 0,"lors de la lecture du nombre de correspondances", NULL); fprintf(stdout,"\n - Il y a %d correspondances sur les aretes %s \n", ncor,nomare[j]); if (ncor > 0) { /* allocation memoire */ cor = (med_int*) malloc(sizeof(med_int)*ncor*2); EXIT_IF(cor == NULL,NULL,NULL); ret = MEDequivLire(fid,nommaa,equ,cor,ncor,MED_ARETE, typare[j]); EXIT_IF(ret < 0,"lors de la lecture du tableau des equivalences", NULL); for (k=0;k<ncor;k++) fprintf(stdout,"\n Correspondance %d : %d et %d \n",k+1,*(cor+2*k), *(cor+2*k+1)); free(cor); } } } /**************************************************************************** * LECTURE DES JOINTS * ****************************************************************************/ fprintf(stdout,"\n(******************************)\n"); fprintf(stdout,"(* JOINTS DU MAILLAGE : *)\n"); fprintf(stdout,"(******************************)\n"); if (njnt == 0) fprintf(stdout,"- Aucun joint \n"); /* lecture de touts les joints associes a nommaa */ for (i = 0;i<njnt;i++) { fprintf(stdout,"- Joint numero : %d ",i+1); /* lecture des infos sur le joint */ ret=MEDjointInfo(fid,nommaa,i+1,jn,des,&ndom,maa_dist); EXIT_IF(ret < 0,"lors de la lecture des informations sur un joint", NULL); fprintf(stdout,"\n - Nom du joint: %s \n",jn); fprintf(stdout,"\n - Description du joint : %s ",des); fprintf(stdout,"\n - Domaine en regard : %d ",ndom); fprintf(stdout,"\n - Maillage distant : %s ",maa_dist); /* lecture des correspondances sur les differents types d'entites */ /* recherche du type des entites en regard... passage par toutes les combinaisons */ for (geo_ent_local=0;nc>0 && geo_ent_local<nb_geo_ent;geo_ent_local++) { for (geo_ent_distant=0;nc>0 && geo_ent_distant<nb_geo_ent;geo_ent_distant++) { typ_ent_local = typ_geo_ent[geo_ent_local][0]; typ_geo_local = typ_geo_ent[geo_ent_local][1]; typ_ent_distant = typ_geo_ent[geo_ent_distant][0]; typ_geo_distant = typ_geo_ent[geo_ent_distant][1]; if (nent=MEDjointnCorres(fid,nommaa,jn,typ_ent_local,typ_geo_local,typ_ent_distant,typ_geo_distant)) { if (nent > 0) { fprintf(stdout,"\n\t\t- nb de couples d'entites en regard (local,distant)=(%s,%s) : %d \n", nom_geo_ent[geo_ent_local],nom_geo_ent[geo_ent_distant],nent); fprintf(stdout," %d \n",nent); cortab = (med_int*) malloc(sizeof(med_int)*nent*2); if (MEDjointLire(fid,nommaa,jn,cortab,nc*2, typ_ent_local,typ_geo_local,typ_ent_distant,typ_geo_distant) < 0) { fprintf(stdout,"\n\t\t- Erreur a la lecture des correspondances sur (%d,%d,%d,%d)", typ_ent_local,typ_geo_local,typ_ent_distant,typ_geo_distant,0); } else { for (k=0;k<nent;k++) fprintf(stdout,"\n\t\t- Correspondance %d : %d et %d ",k+1,*(cortab+2*k), *(cortab+2*k+1)); } free(cortab); } nc--; } } } } return; } /****************************************************************************** * * - Nom de la fonction : lecture_maillage_structure * - Description : lecture et affichage d'un maillage MED__STRUCTURE. * - Parametres : * - fid (IN) : ID du fichier MED. * - nommaa (IN) : nom du maillage a lire. * - mdim (IN) : dimension du maillage. * - mode_coo (IN) : mode de stockage en memoire : * MED_FULL_INTERLACE | MED_NO_INTERLACE. * - lecture_en_tete_seulement (IN) : mode de lecture. * ******************************************************************************/ void lecture_maillage_structure(med_idt fid,char *nommaa,med_int mdim, med_mode_switch mode_coo,int lecture_en_tete_seulement) { med_err ret = 0; med_int axe,i,j; med_int nind; char comp_ind[MED_TAILLE_PNOM+1]; char unit_ind[MED_TAILLE_PNOM+1]; char comp[3*MED_TAILLE_PNOM+1]; char unit[3*MED_TAILLE_PNOM+1]; char str[MED_TAILLE_PNOM+1]; med_float *coo,*indices; med_int *structure_grille; med_table quoi; med_int nnoe; med_type_grille type; med_repere repere; /* familles */ med_int nfam; med_int natt,ngro; char *attdes,*gro; med_int *attval,*attide; char nomfam[MED_TAILLE_NOM+1]; med_int numfam, *nufano; char str1[MED_TAILLE_DESC+1]; char str2[MED_TAILLE_LNOM+1]; ret = MEDnatureGrilleLire(fid,nommaa,&type); EXIT_IF(ret < 0,"lors de lecture du type d'une grille ",NULL); switch(type) { case MED_GRILLE_CARTESIENNE: fprintf(stdout,"- Type de grille : MED_GRILLE_CARTESIENNE \n"); nnoe = 1; for (axe=1;axe<=mdim;axe++) { switch(axe) { case 1: quoi = MED_COOR_IND1; break; case 2: quoi = MED_COOR_IND2; break; case 3: quoi = MED_COOR_IND3; break; } nind = MEDnEntMaa(fid,nommaa,quoi,MED_NOEUD,0,0); nnoe = nind * nnoe; EXIT_IF(nind < 0,"lors de la lecture de la taille d'un indice d'une grille", NULL); fprintf(stdout,"- Taille de l'indice de l'axe %d des coordonnees : %d \n",axe,nind); } break; case MED_GRILLE_POLAIRE: fprintf(stdout,"- Type de grille : MED_GRILLE_POLAIRE \n"); nnoe = 1; for (axe=1;axe<=mdim;axe++) { switch(axe) { case 1: quoi = MED_COOR_IND1; break; case 2: quoi = MED_COOR_IND2; break; case 3: quoi = MED_COOR_IND3; break; } nind = MEDnEntMaa(fid,nommaa,quoi,MED_NOEUD,0,0); nnoe = nind * nnoe; EXIT_IF(nind < 0,"lors de la lecture de la taille d'un indice d'une grille", NULL); fprintf(stdout,"- Taille de l'indice de l'axe %d des coordonnees : %d \n",axe,nind); } break; case MED_GRILLE_STANDARD: fprintf(stdout,"- Type de grille : MED_GRILLE_DESTRUCTUREE \n"); nnoe = MEDnEntMaa(fid,nommaa,MED_COOR,MED_NOEUD,0,0); EXIT_IF(nnoe < 0,"lors de la lecture du nombre de noeuds du maillage ",nommaa); fprintf(stdout,"- Nombre de noeuds : %d \n",nnoe); break; } /* nombre de familles */ nfam = MEDnFam(fid,nommaa); EXIT_IF(nfam < 0,"lors de la lecture du nombre de familles",NULL); fprintf(stdout,"- Nombre de familles : %d \n",nfam); if (lecture_en_tete_seulement) return ; fprintf(stdout,"\n(*************************)\n"); fprintf(stdout,"(* NOEUDS DE LA GRILLE : *)\n"); fprintf(stdout,"(*************************)\n"); switch(type) { case MED_GRILLE_CARTESIENNE : case MED_GRILLE_POLAIRE : /* on affiche les coordonnees de chacun des axes */ for (axe = 1; axe<=mdim; axe++) { /* on alloue la memoire */ indices = (med_float *) malloc(sizeof(med_float)*nind); EXIT_IF(indices == NULL,NULL,NULL); /* on lit le tableau des indices de coordonnees et on affiche le resultat */ ret = MEDindicesCoordLire(fid,nommaa,mdim,indices,nind, axe,comp_ind,unit_ind); EXIT_IF(ret < 0,"lors de la lecture d'un tableau d'indice", NULL); fprintf(stdout,"\n - Axe %s [%s] : [ ",comp_ind,unit_ind); for (j=0;j<nind;j++) fprintf(stdout," %f ",*(indices+j)); printf(" ] \n"); /* on nettoie la memoire */ free(indices); } break; case MED_GRILLE_STANDARD: /* on alloue la memoire */ structure_grille = (med_int *) malloc(sizeof(med_int)*mdim); EXIT_IF(structure_grille == NULL,NULL,NULL); /* on lit la structure de la grille et on affiche le resultat */ ret = MEDstructureCoordLire(fid,nommaa,mdim,structure_grille); EXIT_IF(ret < 0,"lors de la lecture de la structure de la grille", NULL); for (j=0;j<mdim;j++) fprintf(stdout," %d ",*(structure_grille+j)); fprintf(stdout," ] \n"); /* on nettoie la memoire */ free(structure_grille); /* on alloue la memoire */ coo = (med_float *) malloc(sizeof(med_float)*nnoe*mdim); EXIT_IF(coo == NULL,NULL,NULL); /* on va lire les coordonnees des noeuds */ ret = MEDcoordLire(fid,nommaa,mdim,coo,MED_FULL_INTERLACE,MED_ALL,NULL,0, &repere,comp,unit); EXIT_IF(ret < 0,"lors de la lecture des noeuds du maillage",NULL); /* on affiche le resultat */ fprintf(stdout,"- Nom des coordonnees : \n"); for (i=0;i<mdim;i++) { strncpy(str,comp+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM); str[MED_TAILLE_PNOM] = '\0'; fprintf(stdout," %s ",str); } fprintf(stdout,"\n- Unites des coordonnees : \n"); for (i=0;i<mdim;i++) { strncpy(str,unit+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM); str[MED_TAILLE_PNOM] = '\0'; fprintf(stdout," %s ",str); } fprintf(stdout,"\n - Coordonnees des noeuds : [ "); for (j=0;j<nnoe*mdim;j++) fprintf(stdout," %f ",*(coo+j)); fprintf(stdout," ] \n"); /* on nettoie la memoire */ free(coo); break; } /* lecture des numeros de familles de noeuds */ /* on alloue la memoire */ nufano = (med_int *) malloc(sizeof(med_int)*nnoe); EXIT_IF(nufano == NULL,NULL,NULL); /* on va lire les numeros de familles des noeuds */ ret = MEDfamLire(fid,nommaa,nufano,nnoe,MED_NOEUD,0); EXIT_IF(ret < 0,"lors de la lecture des numeros de familles des noeuds", NULL); /* on affiche le resultat */ fprintf(stdout,"\n- Numeros des familles des noeuds : \n"); for (i=0;i<nnoe;i++) fprintf(stdout," %d ",*(nufano+i)); fprintf(stdout,"\n"); printf("\n(*************************)\n"); printf("(* FAMILLES DU MAILLAGE : *)\n"); printf("(*************************)\n"); for (i=0;i<nfam;i++) { /* nombre de groupes */ ngro = MEDnGroupe(fid,nommaa,i+1); EXIT_IF(ngro < 0,"lors de la lecture du nombre de groupe d'une famille",NULL); /* nombre d'attributs */ natt = MEDnAttribut(fid,nommaa,i+1); EXIT_IF(natt < 0,"lors de la lecture du nombre d'attributs d'une famille",NULL); fprintf(stdout,"- Famille %d a %d attributs et %d groupes \n",i+1,natt,ngro); /* nom,numero,attributs,groupes */ /* allocation memoire */ attide = (med_int*) malloc(sizeof(med_int)*natt); EXIT_IF(attide == NULL,NULL,NULL); attval = (med_int*) malloc(sizeof(med_int)*natt); EXIT_IF(attval == NULL,NULL,NULL); attdes = (char *) malloc(MED_TAILLE_DESC*natt+1); EXIT_IF(attdes == NULL,NULL,NULL); gro = (char*) malloc(MED_TAILLE_LNOM*ngro+1); EXIT_IF(gro == NULL,NULL,NULL); ret = MEDfamInfo(fid,nommaa,i+1,nomfam,&numfam,attide,attval, attdes,&natt,gro,&ngro); EXIT_IF(ret < 0,"lors de la lecture des informations d'une famille", NULL); /* affichage des resultats */ fprintf(stdout," - Famille de nom %s et de numero %d : \n",nomfam,numfam); fprintf(stdout," - Attributs : \n"); for (j=0;j<natt;j++) { strncpy(str1,attdes+j*MED_TAILLE_DESC,MED_TAILLE_DESC); str1[MED_TAILLE_DESC] = '\0'; fprintf(stdout," ide = %d - val = %d - des = %s\n",*(attide+j), *(attval+j),str1); } free(attide); free(attval); free(attdes); fprintf(stdout," - Groupes :\n"); for (j=0;j<ngro;j++) { strncpy(str2,gro+j*MED_TAILLE_LNOM,MED_TAILLE_LNOM); str2[MED_TAILLE_LNOM] = '\0'; fprintf(stdout," gro = %s\n",str2); } free(gro); } return ; } med_err getFieldsOn(med_idt fid, char * nomcha, med_type_champ typcha, med_int ncomp, med_entite_maillage entite, med_mode_switch stockage) { int j,k,l,m,n,nb_geo; med_int nbpdtnor=0,pflsize,*pflval,ngauss=0,*vale=NULL,nval; med_int numdt=0,numo=0,lnsize,nbrefmaa; med_float *valr=NULL,dt=0.0; med_err ret=0; med_booleen local; char pflname [MED_TAILLE_NOM+1]=""; char locname [MED_TAILLE_NOM+1]=""; char * lien = NULL; char maa_ass [MED_TAILLE_NOM+1]=""; char dt_unit [MED_TAILLE_PNOM+1]=""; med_geometrie_element * type_geo; med_geometrie_element typ_noeud[1] = { MED_NONE }; med_geometrie_element typmai[MED_NBR_GEOMETRIE_MAILLE+2] = {MED_POINT1, MED_SEG2, MED_SEG3, MED_TRIA3, MED_QUAD4, MED_TRIA6,MED_QUAD8, MED_TETRA4, MED_PYRA5, MED_PENTA6, MED_HEXA8, MED_TETRA10, MED_PYRA13, MED_PENTA15, MED_HEXA20, MED_POLYGONE, MED_POLYEDRE}; med_geometrie_element typfac[MED_NBR_GEOMETRIE_FACE+1] = {MED_TRIA3,MED_TRIA6, MED_QUAD4,MED_QUAD8, MED_POLYGONE}; med_geometrie_element typare[MED_NBR_GEOMETRIE_ARETE] = {MED_SEG2,MED_SEG3}; char ** AFF; switch (entite) { case MED_NOEUD : type_geo = typ_noeud; nb_geo = 1; AFF = MED_GEOMETRIE_NOEUD_AFF; break; case MED_MAILLE : type_geo = typmai; nb_geo = MED_NBR_GEOMETRIE_MAILLE+2; AFF = MED_GEOMETRIE_MAILLE_AFF; break; case MED_FACE : type_geo = typfac; nb_geo = MED_NBR_GEOMETRIE_FACE+1; AFF = MED_GEOMETRIE_FACE_AFF; break; case MED_ARETE : type_geo = typare; nb_geo = MED_NBR_GEOMETRIE_ARETE; AFF = MED_GEOMETRIE_ARETE_AFF; break; } for (k=0;k<nb_geo;k++) { /* Combien de (PDT,NOR) a lire */ nbpdtnor = MEDnPasdetemps(fid,nomcha,entite,type_geo[k]); if (nbpdtnor < 1 ) continue; for (j=0;j<nbpdtnor;j++) { if ( MEDpasdetempsInfo(fid,nomcha,entite,type_geo[k], j+1, &ngauss, &numdt, &numo, dt_unit, &dt, maa_ass, &local, &nbrefmaa) <0) { MESSAGE("Erreur a la demande d'information sur (pdt,nor) : "); ISCRUTE(numdt); ISCRUTE(numo); ret = -1; continue; }; printf("\n +Pas de Temps n.%i (%f) [%s], n. d'ordre %i, avec %i pts de gauss sur le maillage par defaut.\n",numdt,dt,dt_unit,numo,ngauss); printf("\tLe maillage par defaut est : |%s|, sur un total de : %i maillages associes\n", maa_ass, nbrefmaa); /* Le maillage reference est-il porte par un autre fichier */ if ( !local ) { if ( (lnsize=MEDnValLien(fid,maa_ass) ) < 0 ) { MESSAGE("Erreur a la lecture de la taille du lien : "); SSCRUTE(maa_ass); ret = -1; } else { lien = malloc(lnsize*sizeof(char)); EXIT_IF(lien == NULL,NULL,NULL); if ( MEDlienLire(fid, lien, maa_ass) < 0 ) { MESSAGE("Erreur a la lecture du lien : "); SSCRUTE(maa_ass);SSCRUTE(lien); ret = -1; } else { printf("\tLe maillage |%s| est porte par un fichier distant |%s|\n",maa_ass,lien); } free(lien); } } /* Combien de maillages lies aux (nomcha,ent,geo,numdt,numo) */ /* Notons que cette information est egalement disponible a partir de MEDpasdetempsInfo */ if ( (nbrefmaa = MEDnChampRef(fid,nomcha,entite,type_geo[k],numdt,numo) ) < 0 ) { MESSAGE("Erreur a la demande du nombre de maillages references par le champ : "); SSCRUTE(nomcha); ISCRUTE(numdt); ISCRUTE(numo); ret = -1; continue; }; for (l=0;l<nbrefmaa;l++) { if ( MEDchampRefInfo(fid,nomcha,entite,type_geo[k], l+1,numdt, numo, maa_ass, &local, &ngauss) <0 ) { MESSAGE("Erreur a la demande d'information sur le maillage utilise par le champ n° : "); ISCRUTE(l+1); ret = -1; continue; }; /* Prend en compte le nbre de pt de gauss automatiquement */ if ((nval = MEDnVal(fid,nomcha,entite,type_geo[k],numdt,numo,maa_ass,USER_MODE)) <= 0) { MESSAGE("Erreur a la lecture du nombre de valeurs du champ : "); SSCRUTE(nomcha);ISCRUTE(entite);ISCRUTE(type_geo[k]); ISCRUTE(numdt);ISCRUTE(numo);SSCRUTE(maa_ass);ISCRUTE(USER_MODE); ret = -1; continue; }; printf("\t- Il y a %d valeurs en mode %i. Chaque entite %s\ de type geometrique %s associes au maillage |%s| a %i pts de gauss \n", nval,USER_MODE,MED_ENTITE_MAILLAGE_AFF[(int)entite],AFF[k],maa_ass,ngauss); /* Le maillage reference est-il porte par un autre fichier */ if ( !local ) { if ( (lnsize=MEDnValLien(fid,maa_ass) ) < 0 ) { MESSAGE("Erreur a la lecture de la taille du lien : "); SSCRUTE(maa_ass); ret = -1; } else { lien = malloc(lnsize*sizeof(char)); EXIT_IF(lien == NULL,NULL,NULL); if ( MEDlienLire(fid, lien, maa_ass) < 0 ) { MESSAGE("Erreur a la lecture du lien : "); SSCRUTE(maa_ass);SSCRUTE(lien); ret = -1; } else { printf("\tLe maillage |%s| est porte par un fichier distant |%s|\n",maa_ass,lien); } free(lien); } } /*Lecture des valeurs du champ */ if (typcha == MED_FLOAT64) { valr = (med_float*) calloc(ncomp*nval,sizeof(med_float)); EXIT_IF(valr == NULL,NULL,NULL); if ( MEDchampLire(fid,maa_ass,nomcha,(unsigned char*)valr,stockage,MED_ALL,locname, pflname,USER_MODE,entite,type_geo[k],numdt,numo) < 0 ) { MESSAGE("Erreur a la lecture du nombre de valeurs du champ : "); SSCRUTE(nomcha);ISCRUTE(entite);ISCRUTE(type_geo[k]); ISCRUTE(numdt);ISCRUTE(numo);SSCRUTE(maa_ass); ret = -1; }; } else { vale = (med_int*) calloc(ncomp*nval,sizeof(med_int)); EXIT_IF(vale == NULL,NULL,NULL); if ( MEDchampLire(fid,maa_ass,nomcha,(unsigned char*)vale,stockage,MED_ALL,locname, pflname,USER_MODE,entite,type_geo[k],numdt,numo) < 0 ) { MESSAGE("Erreur a la lecture des valeurs du champ : "); SSCRUTE(nomcha);ISCRUTE(entite);ISCRUTE(type_geo[k]); ISCRUTE(numdt);ISCRUTE(numo);SSCRUTE(maa_ass); ret = -1; }; } switch (stockage) { case MED_FULL_INTERLACE : printf("\t- Valeurs :\n\t"); for (m=0;m<nval/ngauss;m++) { printf("|"); for (n=0;n<ngauss*ncomp;n++) if (typcha == MED_FLOAT64) printf(" %f ",*(valr+(m*ngauss*ncomp)+n)); else printf(" %d ",*(vale+(m*ngauss*ncomp)+n)); } break; case MED_NO_INTERLACE : printf("\t- Valeurs :\n\t"); for (m=0;m<ncomp;m++) { printf("|"); for (n=0;n<nval;n++) if (typcha == MED_FLOAT64) printf(" %f ",*(valr+(m*nval)+n)); else printf(" %d ",*(vale+(m*nval)+n)); } break; } printf("|\n"); if (typcha == MED_FLOAT64) { if ( valr ) {free(valr);valr = NULL;}} else if (vale) { free(vale);vale = NULL; } /*Lecture du profil associe */ if (strcmp(pflname,MED_NOPFL) == 0 ) printf("\t- Profil : MED_NOPFL\n"); else { if ( (pflsize = MEDnValProfil(fid,pflname)) <0 ) { MESSAGE("Erreur a la lecture du nombre de valeurs du profil : "); SSCRUTE(pflname); ret = -1; continue; } printf("\t- Profil : |%s| de taille %i\n",pflname,pflsize); pflval = (med_int*) malloc(sizeof(med_int)*pflsize); EXIT_IF(pflval == NULL,NULL,NULL); if ( MEDprofilLire(fid,pflval,pflname) <0) { MESSAGE("Erreur a la lecture des valeurs du profil : "); SSCRUTE(pflname); ret = -1; } printf("\t"); for (m=0;m<pflsize;m++) printf(" %i ",*(pflval+m)); printf("\n"); free(pflval); } } } } /* fin for sur les mailles*/ return ret; } /****************************************************************************** * * - Nom de la fonction : lecture_resultats * - Description : lecture et affichage des champs de resultats * associe a un maillage MED. * - Parametres : * - fid (IN) : ID du fichier MED. * - mdim (IN) : dimension du maillage. * - mode_coo (IN) : mode de stockage en memoire : * MED_FULL_INTERLACE | MED_NO_INTERLACE. * - lecture_en_tete_seulement (IN) : mode de lecture. * ******************************************************************************/ void lecture_resultats(med_idt fid, med_mode_switch mode_coo,int lecture_en_tete_seulement) { med_err ret,lret; char pflname[MED_TAILLE_NOM+1]="",nomlien[MED_TAILLE_NOM+1]=""; char * lien = NULL; char *comp, *unit; char nomcha [MED_TAILLE_NOM+1]=""; char locname[MED_TAILLE_NOM+1]=""; med_int mdim,ncomp,ncha,npro,nln,pflsize,*pflval,nval,nloc,ngauss; med_type_champ typcha; med_maillage type; int t1,t2,t3; med_geometrie_element type_geo; med_float *refcoo, *gscoo, *wg; int i,j; if (! lecture_en_tete_seulement) { fprintf(stdout,"\n(************************)\n"); fprintf(stdout,"(* CHAMPS DU MAILLAGE : *)\n"); fprintf(stdout,"(************************)\n"); } /* combien de champs dans le fichier */ ncha = MEDnChamp(fid,0); EXIT_IF(ncha < 0,"lors de la lecture du nombre de champs",NULL); fprintf(stdout,"- Nombre de champs : %d \n",ncha); if (lecture_en_tete_seulement) return; /**************************************************************************** * LECTURE DES CHAMPS * ****************************************************************************/ ret = 0; /* lecture de tous les champs */ for (i =0;i<ncha;i++) { lret = 0; printf("\nChamp numero : |%d| \n",i+1); /* Lecture du nombre de composantes */ if ((ncomp = MEDnChamp(fid,i+1)) < 0) { MESSAGE("Erreur à la lecture du nombre de composantes : "); ISCRUTE(ncomp); ret = -1; continue; } /* Lecture du type du champ, des noms des composantes et du nom de l'unité*/ comp = (char*) malloc(ncomp*MED_TAILLE_PNOM+1); EXIT_IF(comp == NULL,NULL,NULL); unit = (char*) malloc(ncomp*MED_TAILLE_PNOM+1); EXIT_IF(unit == NULL,NULL,NULL); if ( MEDchampInfo(fid,i+1,nomcha,&typcha,comp,unit,ncomp) < 0 ) { MESSAGE("Erreur à la demande d'information sur les champs : "); ret = -1; continue; } printf("Nom du champ : |%s| de type |%d|\n",nomcha,typcha); printf("Nom des composantes : |%s|\n",comp); printf("Unites des composantes : |%s| \n",unit); free(comp); free(unit); lret = getFieldsOn(fid, nomcha, typcha, ncomp, MED_NOEUD,mode_coo); if (lret == 0) lret = getFieldsOn(fid, nomcha, typcha, ncomp, MED_MAILLE,mode_coo); else { MESSAGE("Erreur à la lecture des champs aux noeuds "); ret = -1; continue;} if (lret == 0) lret = getFieldsOn(fid, nomcha, typcha, ncomp, MED_FACE,mode_coo); else { MESSAGE("Erreur à la lecture des champs aux mailles "); ret = -1; continue;} if (lret == 0) lret = getFieldsOn(fid, nomcha, typcha, ncomp, MED_ARETE,mode_coo); else {MESSAGE("Erreur à la lecture des champs aux faces "); ret = -1; continue;} if (lret != 0) {MESSAGE("Erreur à la lecture des champs aux aretes "); ret = -1;}; } /* Interrogation des profils */ npro = MEDnProfil(fid); printf("\nNombre de profils stockes : %i\n\n",npro); for (i=1 ; i <= npro ; i++ ) { if ( MEDprofilInfo(fid, i, pflname, &nval) < 0) { MESSAGE("Erreur a la demande d'information sur le profil n° : "); ISCRUTE(i); ret = -1;continue; } printf("\t- Profil n°%i de nom |%s| et de taille %i\n",i,pflname,nval); pflval = (med_int*) malloc(sizeof(med_int)*nval); if ( MEDprofilLire(fid, pflval, pflname) < 0) { MESSAGE("Erreur a la lecture des valeurs du profil : "); SSCRUTE(pflname); ret = -1; } else { printf("\t"); for (j=0;j<nval;j++) printf(" %i ",*(pflval+j)); printf("\n\n"); } free(pflval); } /* Interrogation des liens */ nln = MEDnLien(fid); printf("\nNombre de liens stockes : %i\n\n",nln); for (i=1 ; i <= nln ; i++ ) { if ( MEDlienInfo(fid, i, nomlien, &nval) < 0) { MESSAGE("Erreur a la demande d'information sur le lien n° : "); ISCRUTE(i); ret = -1;continue; } printf("\t- Lien n°%i de nom |%s| et de taille %i\n",i,nomlien,nval); lien = malloc(nval*sizeof(char)); EXIT_IF(lien == NULL,NULL,NULL); if ( MEDlienLire(fid, lien, nomlien) < 0 ) { MESSAGE("Erreur a la lecture du lien : "); SSCRUTE(nomlien);SSCRUTE(lien); ret = -1; } else printf("\t\t|%s|\n\n",lien); free(lien); } /* Interrogation des localisations des points de GAUSS */ nloc = MEDnGauss(fid); printf("\nNombre de localisations stockees : %i\n\n",nloc); for (i=1 ; i <= nloc ; i++ ) { if ( MEDgaussInfo(fid, i, locname, &type_geo, &ngauss) < 0) { MESSAGE("Erreur a la demande d'information sur la localisation n° : "); ISCRUTE(i); ret = -1;continue; } printf("\t- Loc. n°%i de nom |%s| et nbr. de pts de GAUSS %i\n",i,locname,ngauss); t1 = (type_geo%100)*(type_geo/100); t2 = ngauss*(type_geo/100); t3 = ngauss; refcoo = (med_float *) malloc(sizeof(med_float)*t1 ); gscoo = (med_float *) malloc(sizeof(med_float)*t2 ); wg = (med_float *) malloc(sizeof(med_float)*t3 ); if ( MEDgaussLire(fid, refcoo, gscoo, wg, mode_coo, locname ) < 0) { MESSAGE("Erreur a la lecture des valeurs de la localisation : "); SSCRUTE(locname); ret = -1; } else { printf("\t Coordonnees de l'element de reference de type %i :\n\t\t",type_geo); for (j=0;j<t1;j++) printf(" %f ",*(refcoo+j)); printf("\n"); printf("\t Localisation des points de GAUSS : \n\t\t"); for (j=0;j<t2;j++) printf(" %f ",*(gscoo+j)); printf("\n"); printf("\t Poids associes aux points de GAUSS :\n\t\t"); for (j=0;j<t3;j++) printf(" %f ",*(wg+j)); printf("\n\n"); } free(refcoo); free(gscoo); free(wg); } return; } /****************************************************************************** * * - Nom de la fonction : lecture_parametres_scalaires * - Description : lecture des parametres scalaires definis * hors champs et maillages. * - Parametres : * - fid (IN) : ID du fichier MED. * - lecture_en_tete_seule (IN) : mode de lecture. * ******************************************************************************/ void lecture_parametres_scalaires(med_idt fid,int lecture_en_tete_seulement) { med_err ret = 0; char nom_scalaire[MED_TAILLE_NOM+1]; char description[MED_TAILLE_DESC+1]; med_int vali; med_float valr; med_int i,n,npdt,j; med_type_champ type; med_int numdt,numo; med_float dt; char dt_unit[MED_TAILLE_PNOM+1]; fprintf(stdout,"\n(*******************************)\n"); fprintf(stdout,"(* SCALAIRES HORS MODELE MED : *)\n"); fprintf(stdout,"(*******************************)\n"); /* Combien de variables scalaire ? */ n = MEDnScalaire(fid); EXIT_IF(n < 0,"lors de la lecture du nombre de scalaires",NULL); fprintf(stdout,"- Nombre de variables scalaires : %d\n",n); if (lecture_en_tete_seulement) return ; for (i=1;i<=n;i++) { /* Lecture des infos (type,description) */ ret = MEDscalaireInfo(fid,i,nom_scalaire,&type,description); EXIT_IF(ret < 0,"lors de la lecture des parametres d'un scalaire",NULL); printf("- Scalaire n°%d de nom %s \n",i,nom_scalaire); if (type == MED_FLOAT64) printf(" Type flottant. \n"); else printf(" Type entier. \n"); printf(" Description associee : [%s] \n",description); /* Pour chaque scalaire on regarde les valeurs associees eventuellement a des pas de temps et des numeros d'ordre */ npdt = MEDnScalairePasdetemps(fid,nom_scalaire); EXIT_IF(npdt < 0,"lors de la lecture du nombre de pas de temps d'un scalaire",NULL); printf(" Nombre de valeurs stockees : %d \n",npdt); for (j=1;j<=npdt;j++) { ret = MEDscalairePasdetempsInfo(fid,nom_scalaire,j, &numdt,dt_unit,&dt,&numo); EXIT_IF(ret < 0,"lors de la lecture des parametres d'un pas de temps d'un scalaire",NULL); if (numdt == MED_NOPDT) printf(" - Aucun de pas de temps \n"); else printf(" - Pas de de temps de numero %d de valeur %f [%s] \n",numdt,dt,dt_unit); if (numo == MED_NONOR) printf(" - Aucun numero d'ordre \n"); else printf(" - Numero d'ordre : %d \n",numo); if (type == MED_FLOAT64) ret = MEDscalaireFlottantLire(fid,nom_scalaire,&valr,numdt,numo); else ret = MEDscalaireEntierLire(fid,nom_scalaire,&vali,numdt,numo); EXIT_IF(ret < 0,"lors de la lecture de la valeur d'un scalaire",NULL); } } return ; } /****************************************************************************** * * - Nom de la fonction : main * - Description : outil de DUMP d'un fichier MED. * - Parametres : * - argc (IN) : nombre d'arguments sur la ligne de commande. * - argv (IN) : liste des arguments. * ******************************************************************************/ int main (int argc, char **argv) { med_err ret = 0; int reponse; med_idt fid; int i; int numero; med_mode_switch mode_coo; med_connectivite typ_con; int lecture_en_tete_seulement = 0; char nom_universel[MED_TAILLE_LNOM+1]; med_int long_fichier_en_tete; char *fichier_en_tete; char version_hdf[10]; char version_med[10]; med_int mdim,nmaa; /* nom du maillage */ char nommaa[MED_TAILLE_NOM+1]; char maillage_description[MED_TAILLE_DESC+1]; med_maillage type_maillage; med_int edim; med_int majeur,mineur,release; med_int majeur_lu,mineur_lu,release_lu; med_int nprofils; /**************************************************************************** * TEST DU NOMBRE D'ARGUMENTS * * argument 1 = nom du fichier MED * ****************************************************************************/ EXIT_IF(argc != 2 && argc != 5,"nombre de parametres incorrects\n",NULL); /**************************************************************************** * OUVERTURE DU FICHIER EN LECTURE * ****************************************************************************/ /* on regarde s'il s'agit d'un fichier au format HDF 5 */ ret = MEDformatConforme(argv[1]); EXIT_IF(ret < 0,"Le fichier n'est pas au format HDF V5 !!!",NULL); /* Quelle version de MED est utilise par mdump ? */ MEDversionDonner(&majeur,&mineur,&release); fprintf(stdout,"- Lecture du fichier à l'aide de la bibliothèque MED-fichier V%d.%d.%d \n",majeur,mineur,release); fid = MEDouvrir(argv[1],MED_LECTURE); EXIT_IF( fid < 0,"ouverture du du fichier ",argv[1]); /**************************************************************************** * QUESTIONS PRELIMINAIRES * * 1. Mode d'affichage des coordonnees (entrelace ou non) ? * * 2. Connectivite des elements (nodale ou descendante) * ****************************************************************************/ fprintf(stdout,"\n >>>>>> DUMP DU FICHIER %s >>>>>>\n",argv[1]); /* en-tete du fichier (presence optionnelle) */ long_fichier_en_tete = MEDlFichDes(fid); if (long_fichier_en_tete > 0) { fichier_en_tete = (char *) malloc(sizeof(char)*(long_fichier_en_tete+1)); EXIT_IF(fichier_en_tete == NULL,NULL,NULL); /* on va lire dans le fichier */ ret = MEDfichEntete(fid,MED_FICH_DES,fichier_en_tete); if (ret < 0) free(fichier_en_tete); EXIT_IF(ret < 0,"lecture de l'en-tete du fichier",argv[1]); /* on affiche */ fprintf(stdout,"- En-tete du fichier : %s \n",fichier_en_tete); free(fichier_en_tete); } if (argc == 2) { fprintf(stdout,"(*****************)\n"); fprintf(stdout,"(* PARAMETRAGE : *)\n"); fprintf(stdout,"(*****************)\n"); fprintf(stdout,"- Mode d'affichage des coordonnées des noeuds ? \n"); fprintf(stdout," 1. Mode entrelacé : taper 1 \n"); fprintf(stdout," 2. Mode non entrelacé : taper 2 \n"); reponse = 0; do { fprintf(stdout," Reponse : "); scanf("%d",&reponse); } while (reponse != 1 && reponse != 2); if (reponse == 1) mode_coo = MED_FULL_INTERLACE; else mode_coo = MED_NO_INTERLACE; fprintf(stdout,"- Connectivité des éléments ? \n"); fprintf(stdout," 1. Nodale : taper 1 \n"); fprintf(stdout," 2. Descendante : taper 2 \n"); reponse = 0; do { fprintf(stdout," Reponse : "); scanf("%d",&reponse); } while (reponse != 1 && reponse != 2); if (reponse == 1) typ_con = MED_NOD; else typ_con = MED_DESC; } else { if (! strcmp(argv[3],"NODALE")) typ_con = MED_NOD; if (! strcmp(argv[3],"DESCENDANTE")) typ_con = MED_DESC; if (!strcmp(argv[4],"NO_INTERLACE")) mode_coo = MED_NO_INTERLACE; if (!strcmp(argv[4],"FULL_INTERLACE")) mode_coo = MED_FULL_INTERLACE; if (! strcmp(argv[4],"LECTURE_EN_TETE_SEULEMENT")) lecture_en_tete_seulement = 1; } /**************************************************************************** * QUEL MAILLAGE LIRE * ****************************************************************************/ nmaa = MEDnMaa(fid); EXIT_IF(nmaa < 0,"lors de la lecture du nombre de maillages",NULL); /* Quel maillage lire ? */ if (argc == 2) { fprintf(stdout,"- Il y a %d maillages dans ce fichier \n",nmaa); fprintf(stdout," Lequel voulez-vous lire (1|2|3|...|n) ?\n"); do { fprintf(stdout," Reponse : "); scanf("%d",&numero); } while (numero > nmaa || numero <= 0); } else { numero = atoi(argv[2]); EXIT_IF(numero > nmaa || numero <= 0,"ce numero de maillage n'existe pas",NULL); } /**************************************************************************** * PARAMETRES SCALAIRES HORS MODELE MED * ****************************************************************************/ /* on va lire l'ensemble des parametres scalaire */ lecture_parametres_scalaires(fid,lecture_en_tete_seulement); /**************************************************************************** * INFOS GENERALES SUR LE MAILLAGE * ****************************************************************************/ fprintf(stdout,"\n(********************************************)\n"); fprintf(stdout,"(* INFORMATIONS GENERALES SUR LE MAILLAGE : *)\n"); fprintf(stdout,"(********************************************)\n"); /* lecture du nom et de la dimension du maillage */ ret = MEDmaaInfo(fid,numero,nommaa,&mdim,&type_maillage,maillage_description); EXIT_IF(ret < 0,"Lecture des informations sur le maillage",NULL); edim = MEDdimEspaceLire(fid,nommaa); fprintf(stdout,"- Nom du maillage : <<%s>>\n",nommaa); fprintf(stdout,"- Dimension du maillage : %d\n",mdim); if (edim > mdim) fprintf(stdout,"- La dimension de l'espace est %d \n",edim); if (type_maillage == MED_NON_STRUCTURE) fprintf(stdout,"- Type du maillage : MED_NON_STRUCTURE \n"); else fprintf(stdout,"- Type du maillage : MED_STRUCTURE \n"); fprintf(stdout,"- Description associee au maillage : %s\n",maillage_description); /* lecture du nom universel (presence optionnelle) */ ret = MEDunvLire(fid,nommaa,nom_universel); if (ret == 0) fprintf(stdout,"- Nom universel du maillage : %s \n",nom_universel); else fprintf(stdout,"- Pas de nom universel \n"); /**************************************************************************** * LECTURE DU MAILLAGE ET DES RESULTATS ASSOCIES * ****************************************************************************/ /* en fonction du type du maillage */ if (type_maillage == MED_NON_STRUCTURE) lecture_maillage_non_structure(fid,nommaa,mdim,mode_coo,typ_con, lecture_en_tete_seulement); else lecture_maillage_structure(fid,nommaa,mdim,mode_coo, lecture_en_tete_seulement); /* on lit ensuite les resultats */ lecture_resultats(fid,mode_coo,lecture_en_tete_seulement); /**************************************************************************** * FERMETURE DU FICHIER * ****************************************************************************/ ret = MEDfermer(fid); EXIT_IF(ret < 0,"lors de la fermeture du fichier",argv[1]); fprintf(stdout,"\n >>>>>> FIN DU DUMP DU FICHIER %s >>>>>>\n",argv[1]); return EXIT_SUCCESS; }