1 /**************************************************************************** 2 * COPYRIGHT (C) 1999 - 2003 EDF R&D 3 * THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY 4 * IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE 5 * AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 6 * EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION. 7 * 8 * THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 9 * WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF 10 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU 11 * LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS. 12 * 13 * YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE 14 * ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION, 15 * INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA 16 * 17 ******************************************************************************/ 18 19 /****************************************************************************** 20 * - Nom du fichier : mdump.c 21 * 22 * - Description : utilitaire de dump pour fichier MED V2.2 23 * Ce fichier contient les fonctions suivantes 24 * qui constituent des modeles de programmation 25 * pour une lecture generique d'un fichier MED V2.2 : 26 * - lecture_maillage_non_structure () : 27 * 1. Noeuds. 28 * 2. Mailles : 29 * - APPORT V2.2 : polyedres et polygones. 30 * 3. Faces (connectivite descendante) : 31 * - APPORT V2.2 : polygones. 32 * 4. Aretes (connectivite descendante). 33 * 5. Familles. 34 * 6. Equivalences. 35 * - lecture_maillage_structure () : (APPORT V2.2) 36 * 1. Grille cartesienne | polaire | destructuree 37 * 2. Familles de noeuds. 38 * - lecture_resultats () : 39 * 1. Champs de resultats relatifs à un maillage. 40 * - Entites : 41 * - Noeuds 42 * - Mailles 43 * - Faces 44 * - Aretes 45 * - Gestion des pas de temps et numeros d'ordre : 46 * - APPORT V2.2 : stockage des valeurs 47 * associees a plusieurs maillages sous 48 * un meme pas de temps. 49 * - Gestion des profils. 50 * - Gestion des liens vers des maillages distants 51 * - APPORT V2.2. 52 * - Gestion des points de Gauss : 53 * - APPORT V2.2.: localisation des 54 * points de Gauss. 55 * - lecture_parametres_scalaires () : (APPORT V2.2) 56 * - Valeurs scalaires entieres ou flottantes. 57 * - Gestion des pas de temps et numeros d'ordre. 58 * - main() : infos generales + lecture de tous les champs et 59 * du fichier MED passe en parametre. 60 * 61 *****************************************************************************/ 62 63 #include <med.h> 64 #include <med_utils.h> 65 #include <stdio.h> 66 #include <string.h> 67 #include <stdlib.h> 68 69 #define USER_MODE MED_COMPACT 70 71 /****************************************************************************** 72 * 73 * - Nom de la fonction : lecture_maillage_non_structure 74 * - Description : lecture et affichage d'un maillage MED_NON_STRUCTURE. 75 * - Parametres : 76 * - fid (IN) : ID du fichier MED. 77 * - nommaa (IN) : nom du maillage a lire. 78 * - mdim (IN) : dimension du maillage. 79 * - mode_coo (IN) : mode de stockage en memoire : 80 * MED_FULL_INTERLACE | MED_NO_INTERLACE. 81 * - typ_con (IN) : mode de connectivite : 82 * MED_FULL_INTERLACE | MED_NO_INTERLACE. 83 * - lecture_en_tete_seulement (IN) : mode de lecture. 84 * 85 ******************************************************************************/ 86 87 /* nombre de mailles concernees par les equivalences */ 88 #define NBR_MAILLE_EQU 7 89 90 void lecture_maillage_non_structure(med_idt fid,char *nommaa,med_int mdim, 91 med_mode_switch mode_coo, 92 med_connectivite typ_con, 93 int lecture_en_tete_seulement) 94 { 95 med_err ret = 0; 96 int i,j,k,l; 97 /* nombre d'objets MED */ 98 med_int nnoe; 99 med_int nmai[MED_NBR_GEOMETRIE_MAILLE],nfac[MED_NBR_GEOMETRIE_FACE]; 100 med_int nare[MED_NBR_GEOMETRIE_ARETE]; 101 /* noeuds */ 102 med_float *coo; 103 char nomcoo[3*MED_TAILLE_PNOM+1]; 104 char unicoo[3*MED_TAILLE_PNOM+1]; 105 char *nomnoe; 106 med_int *numnoe; 107 med_int *nufano; 108 med_repere rep; 109 med_booleen inonoe,inunoe; 110 char str[MED_TAILLE_PNOM+1]; 111 /* elements */ 112 med_int edim; 113 med_int taille; 114 med_int *connectivite; 115 char *nomele; 116 med_int *numele; 117 med_int *nufael; 118 med_booleen inoele, inuele; 119 med_geometrie_element typgeo; 120 med_geometrie_element typmai[MED_NBR_GEOMETRIE_MAILLE] = 121 {MED_POINT1,MED_SEG2, 122 MED_SEG3,MED_TRIA3, 123 MED_TRIA6,MED_QUAD4, 124 MED_QUAD8,MED_TETRA4, 125 MED_TETRA10,MED_HEXA8, 126 MED_HEXA20,MED_PENTA6, 127 MED_PENTA15,MED_PYRA5, 128 MED_PYRA13}; 129 med_int desmai[MED_NBR_GEOMETRIE_MAILLE] = {0,2,3,3,3,4,4,4,4,6,6,5,5,5,5}; 130 med_int nmailles[MED_NBR_GEOMETRIE_MAILLE]; 131 char nommai[MED_NBR_GEOMETRIE_MAILLE] [MED_TAILLE_NOM+1] = {"MED_POINT1", 132 "MED_SEG2", 133 "MED_SEG3", 134 "MED_TRIA3", 135 "MED_TRIA6", 136 "MED_QUAD4", 137 "MED_QUAD8", 138 "MED_TETRA4", 139 "MED_TETRA10", 140 "MED_HEXA8", 141 "MED_HEXA20", 142 "MED_PENTA6", 143 "MED_PENTA15", 144 "MED_PYRA5", 145 "MED_PYRA13"}; 146 med_geometrie_element typfac[MED_NBR_GEOMETRIE_FACE] = {MED_TRIA3,MED_TRIA6, 147 MED_QUAD4,MED_QUAD8}; 148 med_int desfac[MED_NBR_GEOMETRIE_FACE] = {3,3,4,4}; 149 med_int nfaces[MED_NBR_GEOMETRIE_FACE]; 150 char nomfac[MED_NBR_GEOMETRIE_FACE][MED_TAILLE_NOM+1] = {"MED_TRIA3", 151 "MED_TRIA6", 152 "MED_QUAD4", 153 "MED_QUAD8"}; 154 med_geometrie_element typare[MED_NBR_GEOMETRIE_ARETE] = {MED_SEG2, 155 MED_SEG3}; 156 med_int desare[MED_NBR_GEOMETRIE_ARETE] = {2,3}; 157 med_int naretes[MED_NBR_GEOMETRIE_ARETE]; 158 char nomare[MED_NBR_GEOMETRIE_ARETE] [MED_TAILLE_NOM+1] = {"MED_SEG2", 159 "MED_SEG3"}; 160 /* familles */ 161 med_int nfam; 162 med_int natt,ngro; 163 char *attdes,*gro; 164 med_int *attval,*attide; 165 char nomfam[MED_TAILLE_NOM+1]; 166 med_int numfam; 167 char str1[MED_TAILLE_DESC+1]; 168 char str2[MED_TAILLE_LNOM+1]; 169 /* equivalences */ 170 med_int nequ,ncor; 171 med_int *cor; 172 char equ[MED_TAILLE_NOM+1]; 173 char des[MED_TAILLE_DESC+1]; 174 /* mailles/faces MED_POLYGONE et MED_POLYEDRE */ 175 med_int nmpolygones,nfpolygones,npolyedres; 176 med_int *indexp, *indexf; 177 int ind1,ind2,np,nf; 178 char tmp[MED_TAILLE_NOM+1]; 179 med_err ret1,ret2,ret3; 180 med_int nfa; 181 182 /* Combien de noeuds ? */ 183 nnoe = MEDnEntMaa(fid,nommaa,MED_COOR,MED_NOEUD,0,0); 184 EXIT_IF(nnoe < 0,"lors de la lecture du nombre de noeuds",NULL); 185 fprintf(stdout,"- Nombre de noeuds : %d \n",nnoe); 186 187 /* Combien de mailles, faces ou aretes ? */ 188 for (i=0;i<MED_NBR_GEOMETRIE_MAILLE;i++) { 189 nmailles[i] = MEDnEntMaa(fid,nommaa,MED_CONN,MED_MAILLE,typmai[i], 190 typ_con); 191 EXIT_IF(nmailles[i] < 0," lors de la lecture du nombre de mailles",NULL); 192 fprintf (stdout,"- Nombre de mailles de type %s : %d \n",nommai[i],nmailles[i]); 193 } 194 195 /* Combien de mailles polygones ? */ 196 nmpolygones = MEDnEntMaa(fid,nommaa,MED_CONN,MED_MAILLE,MED_POLYGONE, 197 typ_con); 198 EXIT_IF(nmpolygones < 0,"lors de la lecture du nombre de mailles polygone \n", 199 NULL); 200 fprintf(stdout,"- Nombre de mailles de type MED_POLYGONE : %d \n",nmpolygones); 201 202 /* Combien de mailles polyedres ? */ 203 npolyedres = MEDnEntMaa(fid,nommaa,MED_CONN,MED_MAILLE,MED_POLYEDRE, 204 typ_con); 205 EXIT_IF(npolyedres < 0,"lors de la lecture du nombre de mailles polyedre \n", 206 NULL); 207 fprintf(stdout,"- Nombre de mailles de type MED_POLYEDRE : %d \n",npolyedres); 208 209 /* Combien de faces ? */ 210 for (i=0;i<MED_NBR_GEOMETRIE_FACE;i++) { 211 nfaces[i] = MEDnEntMaa(fid,nommaa,MED_CONN,MED_FACE,typfac[i], 212 typ_con); 213 EXIT_IF(nfaces[i] < 0,"lors de la lecture du nombre de faces",NULL); 214 fprintf (stdout,"- Nombre de faces de type %s : %d \n",nomfac[i],nfaces[i]); 215 } 216 217 /* Combien de faces polygones ? */ 218 nfpolygones = MEDnEntMaa(fid,nommaa,MED_CONN,MED_FACE,MED_POLYGONE, 219 typ_con); 220 EXIT_IF(nfpolygones < 0,"lors de la lecture du nombre de faces polygone \n", 221 NULL); 222 fprintf(stdout,"- Nombre de faces de type MED_POLYGONE : %d \n",nfpolygones); 223 224 /* Combien d'aretes */ 225 for (i=0;i<MED_NBR_GEOMETRIE_ARETE;i++) { 226 naretes[i] = MEDnEntMaa(fid,nommaa,MED_CONN,MED_ARETE,typare[i], 227 typ_con); 228 EXIT_IF(naretes[i] < 0,"lors de la lecture du nombre d'aretes",NULL); 229 fprintf (stdout,"- Nombre d'aretes de type %s : %d \n",nomare[i],naretes[i]); 230 } 231 232 /* nombre de familles */ 233 nfam = MEDnFam(fid,nommaa); 234 EXIT_IF(nfam < 0,"lors de la lecture du nombre de familles",NULL); 235 fprintf(stdout,"- Nombre de familles : %d \n",nfam); 236 237 /* combien d'equivalences dans le fichier */ 238 nequ = MEDnEquiv(fid,nommaa); 239 EXIT_IF(nequ < 0,"lors de la lecture du nombre d'equivalences",NULL); 240 fprintf(stdout,"- Nombre d'equivalences : %d \n",nequ); 241 242 /* en fonction du mode de lecture, on continue ou non */ 243 if (lecture_en_tete_seulement) 244 return; 245 246 /**************************************************************************** 247 * LECTURE DES NOEUDS * 248 ****************************************************************************/ 249 250 /* Allocations memoires */ 251 /* table des coordonnees 252 profil : (dimension * nombre de noeuds ) */ 253 coo = (med_float*) malloc(sizeof(med_float)*nnoe*mdim); 254 EXIT_IF(coo == NULL,NULL,NULL); 255 /* table des numeros, des numeros de familles des noeuds 256 profil : (nombre de noeuds) */ 257 numnoe = (med_int*) malloc(sizeof(med_int)*nnoe); 258 EXIT_IF(numnoe == NULL,NULL,NULL); 259 nufano = (med_int*) malloc(sizeof(med_int)*nnoe); 260 EXIT_IF(nufano == NULL,NULL,NULL); 261 /* table des noms des noeuds 262 profil : (nnoe*MED_TAILLE_PNOM+1) */ 263 nomnoe = (char*) malloc(MED_TAILLE_PNOM*nnoe+1); 264 EXIT_IF(nomnoe == NULL,NULL,NULL); 265 266 /* lecture des noeuds : 267 - coordonnees 268 - noms (optionnel dans un fichier MED) 269 - numeros (optionnel dans un fichier MED) 270 - numeros des familles */ 271 ret = MEDnoeudsLire(fid,nommaa,mdim,coo,mode_coo,&rep, 272 nomcoo,unicoo,nomnoe,&inonoe,numnoe,&inunoe, 273 nufano,nnoe); 274 EXIT_IF(ret < 0,"lors de la lecture des noeuds du maillage \n",NULL); 275 276 /* affichage des resultats */ 277 fprintf(stdout,"\n(************************)\n"); 278 fprintf(stdout,"(* NOEUDS DU MAILLAGE : *)\n"); 279 fprintf(stdout,"(************************)\n"); 280 fprintf(stdout,"- Type de repere des coordonnees : %d \n",rep); 281 fprintf(stdout,"- Nom des coordonnees : \n"); 282 for (i=0;i<mdim;i++) { 283 strncpy(str,nomcoo+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM); 284 str[MED_TAILLE_PNOM] = '\0'; 285 fprintf(stdout," %s ",str); 286 } 287 fprintf(stdout,"\n- Unites des coordonnees : \n"); 288 for (i=0;i<mdim;i++) { 289 strncpy(str,unicoo+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM); 290 str[MED_TAILLE_PNOM] = '\0'; 291 fprintf(stdout," %s ",str); 292 } 293 fprintf(stdout,"\n- Coordonnees des noeuds : \n"); 294 for (i=0;i<nnoe*mdim;i++) 295 fprintf(stdout," %f ",*(coo+i)); 296 if (inonoe) { 297 fprintf(stdout,"\n- Noms des noeuds : \n"); 298 for (i=0;i<nnoe;i++) { 299 strncpy(str,nomnoe+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM); 300 str[MED_TAILLE_PNOM] = '\0'; 301 fprintf(stdout," %s ",str); 302 } 303 } 304 if (inunoe) { 305 fprintf(stdout,"\n- Numeros des noeuds : \n"); 306 for (i=0;i<nnoe;i++) 307 fprintf(stdout," %d ",*(numnoe+i)); 308 } 309 fprintf(stdout,"\n- Numeros des familles des noeuds : \n"); 310 for (i=0;i<nnoe;i++) 311 fprintf(stdout," %d ",*(nufano+i)); 312 fprintf(stdout,"\n"); 313 314 315 /* liberation memoire */ 316 free(coo); 317 free(nomnoe); 318 free(numnoe); 319 free(nufano); 320 321 /**************************************************************************** 322 * LECTURE DES ELEMENTS * 323 ****************************************************************************/ 324 325 fprintf(stdout,"\n(**************************)\n"); 326 fprintf(stdout,"(* ELEMENTS DU MAILLAGE : *)\n"); 327 fprintf(stdout,"(**************************)"); 328 329 /* Lecture des connectivites, noms, numeros des mailles */ 330 for (i=0;i<MED_NBR_GEOMETRIE_MAILLE;i++) 331 if (nmailles[i] > 0) { 332 333 /* dimension de la maille */ 334 edim = typmai[i] / 100; 335 switch(typ_con) { 336 case MED_NOD : 337 taille = typmai[i]%100; 338 break; 339 340 case MED_DESC : 341 taille = desmai[i]; 342 break; 343 344 default : 345 ret = -1; 346 } 347 348 /* allocation memoire */ 349 connectivite = (med_int*)malloc(sizeof(med_int)*taille*nmailles[i]); 350 EXIT_IF(connectivite == NULL,NULL,NULL); 351 nomele = (char*)malloc(sizeof(char)*MED_TAILLE_PNOM*nmailles[i]+1); 352 EXIT_IF(nomele == NULL,NULL,NULL); 353 numele = (med_int*)malloc(sizeof(med_int)*nmailles[i]); 354 EXIT_IF(numele == NULL,NULL,NULL); 355 nufael = (med_int*)malloc(sizeof(med_int)*nmailles[i]); 356 EXIT_IF(nufael == NULL,NULL,NULL); 357 358 /* lecture des données */ 359 ret = MEDelementsLire(fid,nommaa,mdim,connectivite,mode_coo, 360 nomele,&inoele,numele,&inuele,nufael, 361 nmailles[i],MED_MAILLE,typmai[i], 362 typ_con); 363 EXIT_IF(ret < 0,"lors de la lecture des mailles (conncetivite,numeros,noms et numeros de famille", 364 NULL); 365 366 /* affichage des resultats */ 367 fprintf(stdout,"\n\n- Mailles de type %s : ", nommai[i]); 368 fprintf(stdout,"\n - Connectivité : \n"); 369 for (j=0;j<nmailles[i]*taille;j++) 370 fprintf(stdout," %d ",*(connectivite+j)); 371 if (inoele) { 372 fprintf(stdout,"\n - Noms : \n"); 373 for (j=0;j<nmailles[i];j++) { 374 strncpy(str,nomele+j*MED_TAILLE_PNOM,MED_TAILLE_PNOM); 375 str[MED_TAILLE_PNOM] = '\0'; 376 fprintf(stdout," %s ",str); 377 } 378 } 379 if (inuele) { 380 fprintf(stdout,"\n - Numeros :\n"); 381 for (j=0;j<nmailles[i];j++) 382 fprintf(stdout," %d ",*(numele+j)); 383 } 384 fprintf(stdout,"\n - Numéros de familles : \n"); 385 for (j=0;j<nmailles[i];j++) 386 fprintf(stdout," %d ",*(nufael+j)); 387 388 /* liberation memoire */ 389 free(connectivite); 390 free(nomele); 391 free(numele); 392 free(nufael); 393 } 394 395 /* lecture des mailles de type MED_POLYGONE */ 396 if (nmpolygones > 0) { 397 398 /* quelle taille pour le tableau des connectivites ? */ 399 ret = MEDpolygoneInfo(fid,nommaa,MED_MAILLE,typ_con,&taille); 400 EXIT_IF(ret < 0,"lors de la lecture des parametres des mailles MED_POLYGONE",NULL); 401 402 /* allocation memoire */ 403 indexp = (med_int *) malloc(sizeof(med_int)*(nmpolygones+1)); 404 EXIT_IF(indexp == NULL,NULL,NULL); 405 connectivite = (med_int *) malloc(sizeof(med_int)*taille); 406 EXIT_IF(connectivite == NULL,NULL,NULL); 407 numele = (med_int *) malloc(sizeof(med_int)*nmpolygones); 408 EXIT_IF(numele == NULL,NULL,NULL); 409 nufael = (med_int *) malloc(sizeof(med_int)*nmpolygones); 410 EXIT_IF(nufael == NULL,NULL,NULL); 411 nomele = (char *) malloc(sizeof(char)*MED_TAILLE_PNOM*nmpolygones+1); 412 EXIT_IF(nomele == NULL,NULL,NULL); 413 414 /* lecture de la connectivite des mailles polygones */ 415 ret = MEDpolygoneConnLire(fid,nommaa,indexp,nmpolygones+1,connectivite, 416 MED_MAILLE,typ_con); 417 EXIT_IF(ret < 0,"lors de la lecture des connectivites des mailles de type MED_POLYGONE",NULL); 418 419 /* lecture noms */ 420 ret1 = MEDnomLire(fid,nommaa,nomele,nmpolygones,MED_MAILLE,MED_POLYGONE); 421 422 /* lecture des numeros */ 423 ret2 = (med_int) MEDnumLire(fid,nommaa,numele,nmpolygones, 424 MED_MAILLE,MED_POLYGONE); 425 426 /* lecture des numeros de familles */ 427 ret3 = MEDfamLire(fid,nommaa,nufael,nmpolygones,MED_MAILLE,MED_POLYGONE); 428 if (ret3 < 0) 429 for (i=0;i<nmpolygones;i++) 430 *(nufael+i) = 0; 431 432 /* affichage des resultats */ 433 fprintf(stdout,"\n\n- Mailles de type MED_POLYGONE : "); 434 for (i=0;i<nmpolygones;i++) { 435 fprintf(stdout,"\n >> Maille MED_POLYGONE %d : \n",i+1); 436 fprintf(stdout,"\n - Connectivité : "); 437 ind1 = *(indexp+i)-1; 438 ind2 = *(indexp+i+1)-1; 439 for (j=ind1;j<ind2;j++) 440 printf(" %d ",*(connectivite+j)); 441 if (ret1 == 0) { 442 strncpy(tmp,nomele+j*MED_TAILLE_PNOM,MED_TAILLE_PNOM); 443 tmp[MED_TAILLE_PNOM] = '\0'; 444 fprintf(stdout,"\n - Nom : %s \n",tmp); 445 } 446 if (ret2 == 0) 447 fprintf(stdout,"\n - Numero : %d \n",*(numele+j)); 448 fprintf(stdout,"\n - Numéro de famille : %d \n",*(nufael+j)); 449 } 450 451 /* on libere la memoire */ 452 free(indexp); 453 free(connectivite); 454 free(numele); 455 free(nufael); 456 free(nomele); 457 } 458 459 /* lecture des mailles de type MED_POLYEDRE */ 460 if (npolyedres > 0) { 461 462 /* lecture des parametres de base */ 463 ret = MEDpolyedreInfo(fid,nommaa,typ_con,&nf,&taille); 464 EXIT_IF(ret < 0,"lors de la lecture des parametres des mailles MED_POLYEDRE",NULL); 465 466 /* allocation memoire */ 467 indexp = (med_int *) malloc(sizeof(med_int)*(npolyedres+1)); 468 EXIT_IF(indexp == NULL,NULL,NULL); 469 indexf = (med_int *) malloc(sizeof(med_int)*nf); 470 EXIT_IF(indexf == NULL,NULL,NULL); 471 connectivite = (med_int *) malloc(sizeof(med_int)*taille); 472 EXIT_IF(connectivite == NULL,NULL,NULL); 473 numele = (med_int *) malloc(sizeof(med_int)*npolyedres); 474 EXIT_IF(numele == NULL,NULL,NULL); 475 nufael = (med_int *) malloc(sizeof(med_int)*npolyedres); 476 EXIT_IF(nufael == NULL,NULL,NULL); 477 nomele = (char *) malloc(sizeof(char)*MED_TAILLE_PNOM*npolyedres+1); 478 EXIT_IF(nomele == NULL,NULL,NULL); 479 480 /* lecture de la connectivite des mailles polyedres */ 481 ret = MEDpolyedreConnLire(fid,nommaa,indexp,npolyedres+1,indexf,nf, 482 connectivite,MED_NOD); 483 EXIT_IF(ret < 0,"lors de la lecture de la connectivite des mailles MED_POLYEDRES", 484 NULL); 485 486 /* lecture des noms */ 487 ret1 = MEDnomLire(fid,nommaa,nomele,npolyedres,MED_MAILLE,MED_POLYEDRE); 488 489 /* lecture des numeros */ 490 ret2 = MEDnumLire(fid,nommaa,numele,npolyedres,MED_MAILLE,MED_POLYEDRE); 491 492 /* lecture des numeros de familles */ 493 ret3 = MEDfamLire(fid,nommaa,nufael,npolyedres,MED_MAILLE,MED_POLYEDRE); 494 if (ret3 < 0) 495 for (i=0;i<npolyedres;i++) 496 *(nufael+i) = 0; 497 498 /* affichage des resultats */ 499 fprintf(stdout,"\n\n- Mailles de type MED_POLYEDRE : "); 500 for (i=0;i<npolyedres;i++) { 501 fprintf(stdout,"\n >> Maille MED_POLYEDRE %d : \n",i+1); 502 fprintf(stdout,"\n - Connectivité : "); 503 nfa = *(indexp+i+1) - *(indexp+i); 504 for (j=0;j<nfa;j++) { 505 if (typ_con == MED_NOD) { 506 /* ind2 = indice dans "connectivite" 507 pour acceder au premier noeud de la face */ 508 ind2 = *(indexf+ind1+j) - 1; 509 nnoe = *(indexf+ind1+j+1) - *(indexf+ind1+j); 510 fprintf(stdout," - Face %d : [ ", j+1); 511 for (k=0;k<nnoe;k++) 512 printf(" %d ",*(connectivite+ind2+k)); 513 printf(" ] \n"); 514 } 515 else { 516 nfa = *(indexp+i+1) - *(indexp+i); 517 /* ind1 = indice dans "connectivite" 518 pour acceder aux numeros des faces */ 519 ind1 = *(indexp+i) - 1; 520 for (j=0;j<nfa;j++) 521 fprintf(stdout," - Face %d de numero : %d et de type %d \n", j+1, 522 *(connectivite+ind1+j),*(indexf+ind1+j)); 523 } 524 } 525 if (ret1 == 0) { 526 strncpy(tmp,nomele+j*MED_TAILLE_PNOM,MED_TAILLE_PNOM); 527 tmp[MED_TAILLE_PNOM] = '\0'; 528 fprintf(stdout,"\n - Nom : %s \n",tmp); 529 } 530 if (ret2 == 0) 531 fprintf(stdout,"\n - Numero : %d \n",*(numele+j)); 532 fprintf(stdout,"\n - Numéro de famille : %d \n",*(nufael+j)); 533 } 534 535 /* on libere la memoire */ 536 free(indexp); 537 free(indexf); 538 free(connectivite); 539 free(numele); 540 free(nufael); 541 free(nomele); 542 543 } 544 545 /* lecture des faces */ 546 if (typ_con == MED_DESC) 547 for (i=0;i<MED_NBR_GEOMETRIE_FACE;i++) 548 if (nfaces[i] > 0 ) { 549 550 /* dimension de la face */ 551 edim = typfac[i] / 100; 552 switch(typ_con) { 553 case MED_NOD : 554 taille = typfac[i]%100; 555 break; 556 557 case MED_DESC : 558 taille = desfac[i]; 559 break; 560 561 default : 562 ret = -1; 563 } 564 565 /* allocation memoire */ 566 connectivite = (med_int*)malloc(sizeof(med_int)*taille*nfaces[i]); 567 EXIT_IF(connectivite == NULL,NULL,NULL); 568 nomele = (char*)malloc(sizeof(char)*MED_TAILLE_PNOM*nfaces[i]+1); 569 EXIT_IF(nomele == NULL,NULL,NULL); 570 numele = (med_int*)malloc(sizeof(med_int)*nfaces[i]); 571 EXIT_IF(numele == NULL,NULL,NULL); 572 nufael = (med_int*)malloc(sizeof(med_int)*nfaces[i]); 573 EXIT_IF(nufael == NULL,NULL,NULL); 574 575 /* lecture des données */ 576 ret = MEDelementsLire(fid,nommaa,mdim,connectivite,mode_coo, 577 nomele,&inoele,numele,&inuele,nufael, 578 nfaces[i],MED_FACE,typfac[i], 579 typ_con); 580 EXIT_IF(ret < 0,"lors de la lecture des faces (connectivite,noms,numeros,numeros de familles)", 581 NULL); 582 583 /* affichage des resultats */ 584 fprintf(stdout,"\n- Faces de type %s : ", nomfac[i]); 585 fprintf(stdout,"\n - Connectivité : \n"); 586 for (j=0;j<nfaces[i]*taille;j++) 587 fprintf(stdout," %d ",*(connectivite+j)); 588 if (inoele) { 589 fprintf(stdout,"\n - Noms : \n"); 590 for (j=0;j<nfaces[i];j++) { 591 fprintf(stdout," %d ",*(connectivite+j)); 592 strncpy(str,nomele+j*MED_TAILLE_PNOM,MED_TAILLE_PNOM); 593 str[MED_TAILLE_PNOM] = '\0'; 594 fprintf(stdout," %s ",str); 595 } 596 } 597 if (inuele) { 598 fprintf(stdout,"\n - Numeros :\n"); 599 for (j=0;j<nfaces[i];j++) 600 fprintf(stdout," %d ",*(numele+j)); 601 } 602 fprintf(stdout,"\n - Numéros de familles : \n"); 603 for (j=0;j<nfaces[i];j++) 604 fprintf(stdout," %d ",*(nufael+j)); 605 606 /* liberation memoire */ 607 free(connectivite); 608 free(nomele); 609 free(numele); 610 free(nufael); 611 } 612 613 614 /* lecture des faces de type MED_POLYGONE */ 615 if (nfpolygones > 0) { 616 617 /* quelle taille pour le tableau des connectivites ? */ 618 ret = MEDpolygoneInfo(fid,nommaa,MED_FACE,typ_con,&taille); 619 EXIT_IF(ret < 0,"lors de la lecture des parametres des faces MED_POLYGONE",NULL); 620 621 /* allocation memoire */ 622 indexp = (med_int *) malloc(sizeof(med_int)*(nfpolygones+1)); 623 EXIT_IF(indexp == NULL,NULL,NULL); 624 connectivite = (med_int *) malloc(sizeof(med_int)*taille); 625 EXIT_IF(connectivite == NULL,NULL,NULL); 626 numele = (med_int *) malloc(sizeof(med_int)*nfpolygones); 627 EXIT_IF(numele == NULL,NULL,NULL); 628 nufael = (med_int *) malloc(sizeof(med_int)*nfpolygones); 629 EXIT_IF(nufael == NULL,NULL,NULL); 630 nomele = (char *) malloc(sizeof(char)*MED_TAILLE_PNOM*nfpolygones+1); 631 EXIT_IF(nomele == NULL,NULL,NULL); 632 633 /* lecture de la connectivite des faces polygones */ 634 ret = MEDpolygoneConnLire(fid,nommaa,indexp,nfpolygones+1,connectivite, 635 MED_FACE,typ_con); 636 EXIT_IF(ret < 0,"lors de la lecture des connectivites des faces de type MED_POLYGONE",NULL); 637 638 /* lecture noms */ 639 ret1 = MEDnomLire(fid,nommaa,nomele,nfpolygones,MED_FACE,MED_POLYGONE); 640 641 /* lecture des numeros */ 642 ret2 = (med_int) MEDnumLire(fid,nommaa,numele,nfpolygones, 643 MED_FACE,MED_POLYGONE); 644 645 /* lecture des numeros de familles */ 646 ret3 = MEDfamLire(fid,nommaa,nufael,nfpolygones,MED_FACE,MED_POLYGONE); 647 if (ret3 < 0) 648 for (i=0;i<nfpolygones;i++) 649 *(nufael+i) = 0; 650 651 /* affichage des resultats */ 652 fprintf(stdout,"\n\n- Faces de type MED_POLYGONE : "); 653 for (i=0;i<nfpolygones;i++) { 654 fprintf(stdout,"\n >> Face MED_POLYGONE %d : \n",i+1); 655 fprintf(stdout,"\n - Connectivité : "); 656 ind1 = *(indexp+i)-1; 657 ind2 = *(indexp+i+1)-1; 658 for (j=ind1;j<ind2;j++) 659 fprintf(stdout," %d ",*(connectivite+j)); 660 if (ret1 == 0) { 661 strncpy(tmp,nomele+j*MED_TAILLE_PNOM,MED_TAILLE_PNOM); 662 tmp[MED_TAILLE_PNOM] = '\0'; 663 fprintf(stdout,"\n - Nom : %s \n",tmp); 664 } 665 if (ret2 == 0) 666 fprintf(stdout,"\n - Numero : %d \n",*(numele+j)); 667 fprintf(stdout,"\n - Numéro de famille : %d \n",*(nufael+j)); 668 } 669 670 /* on libere la memoire */ 671 free(indexp); 672 free(connectivite); 673 free(numele); 674 free(nufael); 675 free(nomele); 676 } 677 678 /* les aretes */ 679 if (typ_con == MED_DESC) 680 for (i=0;i<MED_NBR_GEOMETRIE_ARETE;i++) 681 if (naretes[i] > 0) { 682 683 /* dimension de l'arete */ 684 edim = typare[i] / 100; 685 switch(typ_con) { 686 case MED_NOD : 687 taille = typare[i]%100; 688 break; 689 690 case MED_DESC : 691 taille = desare[i]; 692 break; 693 694 default : 695 ret = -1; 696 } 697 698 /* allocation memoire */ 699 connectivite = (med_int*)malloc(sizeof(med_int)*taille*naretes[i]); 700 EXIT_IF(connectivite == NULL,NULL,NULL); 701 nomele = (char*)malloc(sizeof(char)*MED_TAILLE_PNOM*naretes[i]+1); 702 EXIT_IF(nomele == NULL,NULL,NULL); 703 numele = (med_int*)malloc(sizeof(med_int)*naretes[i]); 704 EXIT_IF(numele == NULL,NULL,NULL); 705 nufael = (med_int*)malloc(sizeof(med_int)*naretes[i]); 706 EXIT_IF(nufael == NULL,NULL,NULL); 707 708 /* lecture des données */ 709 ret = MEDelementsLire(fid,nommaa,mdim,connectivite,mode_coo, 710 nomele,&inoele,numele,&inuele,nufael, 711 naretes[i],MED_ARETE,typare[i], 712 typ_con); 713 EXIT_IF(ret < 0,"lors de la lecture des aretes (connectivite,noms,numeros,numeros de familles)", 714 NULL); 715 716 /* affichage des resultats */ 717 fprintf(stdout,"\n- Aretes de type %d : ", nomare[i]); 718 fprintf(stdout,"\n - Connectivité : \n"); 719 for (j=0;j<naretes[i]*taille;j++) 720 fprintf(stdout," %d ",*(connectivite+j)); 721 if (inoele) { 722 fprintf(stdout,"\n - Noms : \n"); 723 for (j=0;j<naretes[i];j++) { 724 fprintf(stdout," %d ",*(connectivite+j)); 725 strncpy(str,nomele+j*MED_TAILLE_PNOM,MED_TAILLE_PNOM); 726 str[MED_TAILLE_PNOM] = '\0'; 727 fprintf(stdout," %s ",str); 728 } 729 } 730 if (inuele) { 731 fprintf(stdout,"\n - Numeros :\n"); 732 for (j=0;j<naretes[i];j++) 733 fprintf(stdout," %d ",*(numele+j)); 734 } 735 fprintf(stdout,"\n - Numéros de familles : \n"); 736 for (j=0;j<naretes[i];j++) 737 fprintf(stdout," %d ",*(nufael+j)); 738 739 /* liberation memoire */ 740 free(connectivite); 741 free(nomele); 742 free(numele); 743 free(nufael); 744 } 745 746 /**************************************************************************** 747 * LECTURE DES FAMILLES * 748 ****************************************************************************/ 749 printf("\n(*************************)\n"); 750 printf("(* FAMILLES DU MAILLAGE : *)\n"); 751 printf("(*************************)\n"); 752 753 for (i=0;i<nfam;i++) { 754 755 /* nombre de groupes */ 756 ngro = MEDnGroupe(fid,nommaa,i+1); 757 EXIT_IF(ngro < 0,"lors de la lecture du nombre de groupe d'une famille",NULL); 758 759 /* nombre d'attributs */ 760 natt = MEDnAttribut(fid,nommaa,i+1); 761 EXIT_IF(natt < 0,"lors de la lecture du nombre d'attributs d'une famille",NULL); 762 763 fprintf(stdout,"- Famille %d a %d attribut(s) et %d groupe(s) \n",i+1,natt,ngro); 764 765 /* nom,numero,attributs,groupes */ 766 767 /* allocation memoire */ 768 attide = (med_int*) malloc(sizeof(med_int)*natt); 769 EXIT_IF(attide == NULL,NULL,NULL); 770 attval = (med_int*) malloc(sizeof(med_int)*natt); 771 EXIT_IF(attval == NULL,NULL,NULL); 772 attdes = (char *) malloc(MED_TAILLE_DESC*natt+1); 773 EXIT_IF(attdes == NULL,NULL,NULL); 774 gro = (char*) malloc(MED_TAILLE_LNOM*ngro+1); 775 EXIT_IF(gro == NULL,NULL,NULL); 776 777 ret = MEDfamInfo(fid,nommaa,i+1,nomfam,&numfam,attide,attval, 778 attdes,&natt,gro,&ngro); 779 EXIT_IF(ret < 0,"lors de la lecture des informations d'une famille", 780 NULL); 781 782 /* affichage des resultats */ 783 fprintf(stdout," - Famille de nom %s et de numero %d : \n",nomfam,numfam); 784 fprintf(stdout," - Attributs : \n"); 785 for (j=0;j<natt;j++) { 786 strncpy(str1,attdes+j*MED_TAILLE_DESC,MED_TAILLE_DESC); 787 str1[MED_TAILLE_DESC] = '\0'; 788 fprintf(stdout," identificateur = %d - valeur = %d - description = %s\n",*(attide+j), 789 *(attval+j),str1); 790 } 791 792 free(attide); 793 free(attval); 794 free(attdes); 795 796 fprintf(stdout," - Groupes :\n"); 797 for (j=0;j<ngro;j++) { 798 strncpy(str2,gro+j*MED_TAILLE_LNOM,MED_TAILLE_LNOM); 799 str2[MED_TAILLE_LNOM] = '\0'; 800 fprintf(stdout," groupe %d = %s\n",j,str2); 801 } 802 803 free(gro); 804 } 805 806 807 808 /**************************************************************************** 809 * LECTURE DES EQUIVALENCES * 810 ****************************************************************************/ 811 fprintf(stdout,"\n(******************************)\n"); 812 fprintf(stdout,"(* EQUIVALENCES DU MAILLAGE : *)\n"); 813 fprintf(stdout,"(******************************)\n"); 814 815 if (nequ == 0) 816 fprintf(stdout,"- Aucune équivalence \n"); 817 818 /* lecture de toutes les equivalences associes a nommaa */ 819 for (i = 0;i<nequ;i++) { 820 fprintf(stdout,"- Equivalence numero : %d ",i+1); 821 822 /* lecture des infos sur l'equivalence */ 823 ret = MEDequivInfo(fid,nommaa,i+1,equ,des); 824 EXIT_IF(ret < 0,"lors de la lecture des informations sur une equivalence", 825 NULL); 826 fprintf(stdout,"\n - Nom de l'equivalence: %s \n",equ); 827 fprintf(stdout,"\n - Description de l'equivalence : %s \n",des); 828 829 /* lecture des correspondances sur les differents types d'entites */ 830 831 /* les noeuds */ 832 ncor = MEDnCorres(fid,nommaa,equ,MED_NOEUD,0); 833 EXIT_IF(ncor < 0,"lors de la lecture du nombre de correspondances d'une equivalence", 834 NULL); 835 fprintf(stdout,"\n - Il y a %d correspondances sur les noeuds \n",ncor); 836 837 if (ncor > 0) { 838 839 /* allocation memoire */ 840 cor = (med_int*) malloc(sizeof(med_int)*ncor*2); 841 EXIT_IF(cor == NULL,NULL,NULL); 842 843 ret = MEDequivLire(fid,nommaa,equ,cor,ncor,MED_NOEUD,0); 844 EXIT_IF(ret < 0,"lors de la lecture du tableau des correspondances", 845 NULL); 846 for (j=0;j<ncor;j++) 847 fprintf(stdout,"\n - Correspondance %d : %d et %d \n",j+1,*(cor+2*j), 848 *(cor+2*j+1)); 849 free(cor); 850 } 851 852 /* sur les mailles : on ne prend pas en compte les mailles 3D */ 853 for (j=0;j<NBR_MAILLE_EQU;j++) { 854 855 ncor = MEDnCorres(fid,nommaa,equ,MED_MAILLE,typmai[j]); 856 EXIT_IF(ncor < 0,"lors de la lecture du nombre de correspondances dans une equivalence", 857 NULL); 858 fprintf(stdout,"\n - Il y a %d correspondances sur les mailles %s \n",ncor, 859 nommai[j]); 860 861 if (ncor > 0) { 862 863 /* allocation memoire */ 864 cor = (med_int*) malloc(sizeof(med_int)*ncor*2); 865 EXIT_IF(cor == NULL,NULL,NULL); 866 867 ret = MEDequivLire(fid,nommaa,equ,cor,ncor,MED_MAILLE, 868 typmai[j]); 869 EXIT_IF(ret < 0,"lors de la lecture du tableau des equivalences", 870 NULL); 871 872 for (k=0;k<ncor;k++) 873 fprintf(stdout,"\n - Correspondance %d : %d et %d \n",k+1,*(cor+2*k), 874 *(cor+2*k+1)); 875 876 free(cor); 877 } 878 } 879 880 /* sur les faces */ 881 for (j=0;j<MED_NBR_GEOMETRIE_FACE;j++) { 882 883 ncor = MEDnCorres(fid,nommaa,equ,MED_FACE,typfac[j]); 884 EXIT_IF(ncor < 0,"lors de la lecture du nombre de correspondances dans une equivalence", 885 NULL); 886 fprintf(stdout,"\n - Il y a %d correspondances sur les faces %s\n",ncor, 887 nomfac[j]); 888 889 if (ncor > 0) { 890 891 /* allocation memoire */ 892 cor = (med_int*) malloc(sizeof(med_int)*ncor*2); 893 EXIT_IF(cor == NULL,NULL,NULL); 894 895 ret = MEDequivLire(fid,nommaa,equ,cor,ncor,MED_FACE, 896 typfac[j]); 897 EXIT_IF(ret < 0,"lors de la lecture du tableau des equivalences", 898 NULL); 899 900 for (k=0;k<ncor;k++) 901 fprintf(stdout,"\n - Correspondance %d : %d et %d \n",k+1,*(cor+2*k), 902 *(cor+2*k+1)); 903 904 free(cor); 905 } 906 } 907 908 /* sur les aretes */ 909 for (j=0;j<MED_NBR_GEOMETRIE_ARETE;j++) { 910 911 ncor = MEDnCorres(fid,nommaa,equ,MED_ARETE,typare[j]); 912 EXIT_IF(ncor < 0,"lors de la lecture du nombre de correspondances", 913 NULL); 914 fprintf(stdout,"\n - Il y a %d correspondances sur les aretes %s \n", 915 ncor,nomare[j]); 916 917 if (ncor > 0) { 918 919 /* allocation memoire */ 920 cor = (med_int*) malloc(sizeof(med_int)*ncor*2); 921 EXIT_IF(cor == NULL,NULL,NULL); 922 923 ret = MEDequivLire(fid,nommaa,equ,cor,ncor,MED_ARETE, 924 typare[j]); 925 EXIT_IF(ret < 0,"lors de la lecture du tableau des equivalences", 926 NULL); 927 928 for (k=0;k<ncor;k++) 929 fprintf(stdout,"\n Correspondance %d : %d et %d \n",k+1,*(cor+2*k), 930 *(cor+2*k+1)); 931 932 free(cor); 933 } 934 } 935 } 936 937 return; 938 } 939 940 941 /****************************************************************************** 942 * 943 * - Nom de la fonction : lecture_maillage_structure 944 * - Description : lecture et affichage d'un maillage MED__STRUCTURE. 945 * - Parametres : 946 * - fid (IN) : ID du fichier MED. 947 * - nommaa (IN) : nom du maillage a lire. 948 * - mdim (IN) : dimension du maillage. 949 * - mode_coo (IN) : mode de stockage en memoire : 950 * MED_FULL_INTERLACE | MED_NO_INTERLACE. 951 * - lecture_en_tete_seulement (IN) : mode de lecture. 952 * 953 ******************************************************************************/ 954 955 void lecture_maillage_structure(med_idt fid,char *nommaa,med_int mdim, 956 med_mode_switch mode_coo,int lecture_en_tete_seulement) 957 { 958 med_err ret = 0; 959 med_int axe,i,j; 960 med_int nind; 961 char comp_ind[MED_TAILLE_PNOM+1]; 962 char unit_ind[MED_TAILLE_PNOM+1]; 963 char comp[3*MED_TAILLE_PNOM+1]; 964 char unit[3*MED_TAILLE_PNOM+1]; 965 char str[MED_TAILLE_PNOM+1]; 966 med_float *coo,*indices; 967 med_int *structure_grille; 968 med_table quoi; 969 med_int nnoe; 970 med_type_grille type; 971 med_repere repere; 972 /* familles */ 973 med_int nfam; 974 med_int natt,ngro; 975 char *attdes,*gro; 976 med_int *attval,*attide; 977 char nomfam[MED_TAILLE_NOM+1]; 978 med_int numfam, *nufano; 979 char str1[MED_TAILLE_DESC+1]; 980 char str2[MED_TAILLE_LNOM+1]; 981 982 ret = MEDnatureGrilleLire(fid,nommaa,&type); 983 EXIT_IF(ret < 0,"lors de lecture du type d'une grille ",NULL); 984 985 switch(type) { 986 987 case MED_GRILLE_CARTESIENNE: 988 fprintf(stdout,"- Type de grille : MED_GRILLE_CARTESIENNE \n"); 989 nnoe = 1; 990 for (axe=1;axe<=mdim;axe++) { 991 switch(axe) { 992 993 case 1: 994 quoi = MED_COOR_IND1; 995 break; 996 997 case 2: 998 quoi = MED_COOR_IND2; 999 break; 1000 1001 case 3: 1002 quoi = MED_COOR_IND3; 1003 break; 1004 } 1005 nind = MEDnEntMaa(fid,nommaa,quoi,MED_NOEUD,0,0); 1006 nnoe = nind * nnoe; 1007 EXIT_IF(nind < 0,"lors de la lecture de la taille d'un indice d'une grille", 1008 NULL); 1009 fprintf(stdout,"- Taille de l'indice de l'axe %d des coordonnees : %d \n",axe,nind); 1010 } 1011 break; 1012 1013 1014 case MED_GRILLE_POLAIRE: 1015 fprintf(stdout,"- Type de grille : MED_GRILLE_POLAIRE \n"); 1016 nnoe = 1; 1017 for (axe=1;axe<=mdim;axe++) { 1018 switch(axe) { 1019 1020 case 1: 1021 quoi = MED_COOR_IND1; 1022 break; 1023 1024 case 2: 1025 quoi = MED_COOR_IND2; 1026 break; 1027 1028 case 3: 1029 quoi = MED_COOR_IND3; 1030 break; 1031 } 1032 nind = MEDnEntMaa(fid,nommaa,quoi,MED_NOEUD,0,0); 1033 nnoe = nind * nnoe; 1034 EXIT_IF(nind < 0,"lors de la lecture de la taille d'un indice d'une grille", 1035 NULL); 1036 fprintf(stdout,"- Taille de l'indice de l'axe %d des coordonnees : %d \n",axe,nind); 1037 } 1038 break; 1039 1040 case MED_GRILLE_STANDARD: 1041 fprintf(stdout,"- Type de grille : MED_GRILLE_DESTRUCTUREE \n"); 1042 nnoe = MEDnEntMaa(fid,nommaa,MED_COOR,MED_NOEUD,0,0); 1043 EXIT_IF(nnoe < 0,"lors de la lecture du nombre de noeuds du maillage ",nommaa); 1044 fprintf(stdout,"- Nombre de noeuds : %d \n",nnoe); 1045 break; 1046 } 1047 1048 /* nombre de familles */ 1049 nfam = MEDnFam(fid,nommaa); 1050 EXIT_IF(nfam < 0,"lors de la lecture du nombre de familles",NULL); 1051 fprintf(stdout,"- Nombre de familles : %d \n",nfam); 1052 1053 if (lecture_en_tete_seulement) 1054 return ; 1055 1056 fprintf(stdout,"\n(*************************)\n"); 1057 fprintf(stdout,"(* NOEUDS DE LA GRILLE : *)\n"); 1058 fprintf(stdout,"(*************************)\n"); 1059 1060 switch(type) { 1061 1062 case MED_GRILLE_CARTESIENNE : 1063 case MED_GRILLE_POLAIRE : 1064 /* on affiche les coordonnees de chacun des axes */ 1065 for (axe = 1; axe<=mdim; axe++) { 1066 /* on alloue la memoire */ 1067 indices = (med_float *) malloc(sizeof(med_float)*nind); 1068 EXIT_IF(indices == NULL,NULL,NULL); 1069 /* on lit le tableau des indices de coordonnees 1070 et on affiche le resultat */ 1071 ret = MEDindicesCoordLire(fid,nommaa,mdim,indices,nind, 1072 axe,comp_ind,unit_ind); 1073 EXIT_IF(ret < 0,"lors de la lecture d'un tableau d'indice", 1074 NULL); 1075 fprintf(stdout,"\n - Axe %s [%s] : [ ",comp_ind,unit_ind); 1076 for (j=0;j<nind;j++) 1077 fprintf(stdout," %f ",*(indices+j)); 1078 printf(" ] \n"); 1079 /* on nettoie la memoire */ 1080 free(indices); 1081 } 1082 break; 1083 1084 case MED_GRILLE_STANDARD: 1085 /* on alloue la memoire */ 1086 structure_grille = (med_int *) malloc(sizeof(med_int)*mdim); 1087 EXIT_IF(structure_grille == NULL,NULL,NULL); 1088 /* on lit la structure de la grille 1089 et on affiche le resultat */ 1090 ret = MEDstructureCoordLire(fid,nommaa,mdim,structure_grille); 1091 EXIT_IF(ret < 0,"lors de la lecture de la structure de la grille", 1092 NULL); 1093 for (j=0;j<mdim;j++) 1094 fprintf(stdout," %d ",*(structure_grille+j)); 1095 fprintf(stdout," ] \n"); 1096 /* on nettoie la memoire */ 1097 free(structure_grille); 1098 1099 /* on alloue la memoire */ 1100 coo = (med_float *) malloc(sizeof(med_float)*nnoe*mdim); 1101 EXIT_IF(coo == NULL,NULL,NULL); 1102 /* on va lire les coordonnees des noeuds */ 1103 ret = MEDcoordLire(fid,nommaa,mdim,coo,MED_FULL_INTERLACE,MED_ALL,NULL,0, 1104 &repere,comp,unit); 1105 EXIT_IF(ret < 0,"lors de la lecture des noeuds du maillage",NULL); 1106 /* on affiche le resultat */ 1107 fprintf(stdout,"- Nom des coordonnees : \n"); 1108 for (i=0;i<mdim;i++) { 1109 strncpy(str,comp+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM); 1110 str[MED_TAILLE_PNOM] = '\0'; 1111 fprintf(stdout," %s ",str); 1112 } 1113 fprintf(stdout,"\n- Unites des coordonnees : \n"); 1114 for (i=0;i<mdim;i++) { 1115 strncpy(str,unit+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM); 1116 str[MED_TAILLE_PNOM] = '\0'; 1117 fprintf(stdout," %s ",str); 1118 } 1119 fprintf(stdout,"\n - Coordonnees des noeuds : [ "); 1120 for (j=0;j<nnoe*mdim;j++) 1121 fprintf(stdout," %f ",*(coo+j)); 1122 fprintf(stdout," ] \n"); 1123 /* on nettoie la memoire */ 1124 free(coo); 1125 break; 1126 } 1127 1128 /* lecture des numeros de familles de noeuds */ 1129 1130 /* on alloue la memoire */ 1131 nufano = (med_int *) malloc(sizeof(med_int)*nnoe); 1132 EXIT_IF(nufano == NULL,NULL,NULL); 1133 1134 /* on va lire les numeros de familles des noeuds */ 1135 ret = MEDfamLire(fid,nommaa,nufano,nnoe,MED_NOEUD,0); 1136 EXIT_IF(ret < 0,"lors de la lecture des numeros de familles des noeuds", 1137 NULL); 1138 1139 /* on affiche le resultat */ 1140 fprintf(stdout,"\n- Numeros des familles des noeuds : \n"); 1141 for (i=0;i<nnoe;i++) 1142 fprintf(stdout," %d ",*(nufano+i)); 1143 fprintf(stdout,"\n"); 1144 1145 printf("\n(*************************)\n"); 1146 printf("(* FAMILLES DU MAILLAGE : *)\n"); 1147 printf("(*************************)\n"); 1148 1149 for (i=0;i<nfam;i++) { 1150 1151 /* nombre de groupes */ 1152 ngro = MEDnGroupe(fid,nommaa,i+1); 1153 EXIT_IF(ngro < 0,"lors de la lecture du nombre de groupe d'une famille",NULL); 1154 1155 /* nombre d'attributs */ 1156 natt = MEDnAttribut(fid,nommaa,i+1); 1157 EXIT_IF(natt < 0,"lors de la lecture du nombre d'attributs d'une famille",NULL); 1158 1159 fprintf(stdout,"- Famille %d a %d attributs et %d groupes \n",i+1,natt,ngro); 1160 1161 /* nom,numero,attributs,groupes */ 1162 1163 /* allocation memoire */ 1164 attide = (med_int*) malloc(sizeof(med_int)*natt); 1165 EXIT_IF(attide == NULL,NULL,NULL); 1166 attval = (med_int*) malloc(sizeof(med_int)*natt); 1167 EXIT_IF(attval == NULL,NULL,NULL); 1168 attdes = (char *) malloc(MED_TAILLE_DESC*natt+1); 1169 EXIT_IF(attdes == NULL,NULL,NULL); 1170 gro = (char*) malloc(MED_TAILLE_LNOM*ngro+1); 1171 EXIT_IF(gro == NULL,NULL,NULL); 1172 1173 ret = MEDfamInfo(fid,nommaa,i+1,nomfam,&numfam,attide,attval, 1174 attdes,&natt,gro,&ngro); 1175 EXIT_IF(ret < 0,"lors de la lecture des informations d'une famille", 1176 NULL); 1177 1178 /* affichage des resultats */ 1179 fprintf(stdout," - Famille de nom %s et de numero %d : \n",nomfam,numfam); 1180 fprintf(stdout," - Attributs : \n"); 1181 for (j=0;j<natt;j++) { 1182 strncpy(str1,attdes+j*MED_TAILLE_DESC,MED_TAILLE_DESC); 1183 str1[MED_TAILLE_DESC] = '\0'; 1184 fprintf(stdout," ide = %d - val = %d - des = %s\n",*(attide+j), 1185 *(attval+j),str1); 1186 } 1187 1188 free(attide); 1189 free(attval); 1190 free(attdes); 1191 1192 fprintf(stdout," - Groupes :\n"); 1193 for (j=0;j<ngro;j++) { 1194 strncpy(str2,gro+j*MED_TAILLE_LNOM,MED_TAILLE_LNOM); 1195 str2[MED_TAILLE_LNOM] = '\0'; 1196 fprintf(stdout," gro = %s\n",str2); 1197 } 1198 1199 free(gro); 1200 } 1201 1202 return ; 1203 } 1204 1205 1206 med_err getFieldsOn(med_idt fid, char * nomcha, med_type_champ typcha, med_int ncomp, 1207 med_entite_maillage entite, med_mode_switch stockage) { 1208 1209 int j,k,l,m,n,nb_geo; 1210 med_int nbpdtnor=0,pflsize,*pflval,ngauss=0,*vale=NULL,nval; 1211 med_int numdt=0,numo=0,lnsize,nbrefmaa; 1212 med_float *valr=NULL,dt=0.0; 1213 med_err ret=0; 1214 med_booleen local; 1215 char pflname [MED_TAILLE_NOM+1]=""; 1216 char locname [MED_TAILLE_NOM+1]=""; 1217 char * lien = NULL; 1218 char maa_ass [MED_TAILLE_NOM+1]=""; 1219 char dt_unit [MED_TAILLE_PNOM+1]=""; 1220 1221 1222 med_geometrie_element * type_geo; 1223 med_geometrie_element typ_noeud[1] = { MED_NONE }; 1224 med_geometrie_element typmai[MED_NBR_GEOMETRIE_MAILLE+2] = {MED_POINT1, MED_SEG2, MED_SEG3, MED_TRIA3, 1225 MED_QUAD4, MED_TRIA6,MED_QUAD8, MED_TETRA4, 1226 MED_PYRA5, MED_PENTA6, MED_HEXA8, MED_TETRA10, 1227 MED_PYRA13, MED_PENTA15, MED_HEXA20, 1228 MED_POLYGONE, MED_POLYEDRE}; 1229 med_geometrie_element typfac[MED_NBR_GEOMETRIE_FACE+1] = {MED_TRIA3,MED_TRIA6, 1230 MED_QUAD4,MED_QUAD8, 1231 MED_POLYGONE}; 1232 med_geometrie_element typare[MED_NBR_GEOMETRIE_ARETE] = {MED_SEG2,MED_SEG3}; 1233 1234 char ** AFF; 1235 1236 switch (entite) { 1237 case MED_NOEUD : 1238 type_geo = typ_noeud; 1239 nb_geo = 1; 1240 AFF = MED_GEOMETRIE_NOEUD_AFF; 1241 break; 1242 case MED_MAILLE : 1243 type_geo = typmai; 1244 nb_geo = MED_NBR_GEOMETRIE_MAILLE+2; 1245 AFF = MED_GEOMETRIE_MAILLE_AFF; 1246 break; 1247 case MED_FACE : 1248 type_geo = typfac; 1249 nb_geo = MED_NBR_GEOMETRIE_FACE+1; 1250 AFF = MED_GEOMETRIE_FACE_AFF; 1251 break; 1252 case MED_ARETE : 1253 type_geo = typare; 1254 nb_geo = MED_NBR_GEOMETRIE_ARETE; 1255 AFF = MED_GEOMETRIE_ARETE_AFF; 1256 break; 1257 } 1258 1259 1260 for (k=0;k<nb_geo;k++) { 1261 1262 /* Combien de (PDT,NOR) a lire */ 1263 nbpdtnor = MEDnPasdetemps(fid,nomcha,entite,type_geo[k]); 1264 if (nbpdtnor < 1 ) continue; 1265 1266 for (j=0;j<nbpdtnor;j++) { 1267 1268 if ( MEDpasdetempsInfo(fid,nomcha,entite,type_geo[k], 1269 j+1, &ngauss, &numdt, &numo, dt_unit, 1270 &dt, maa_ass, &local, &nbrefmaa) <0) { 1271 MESSAGE("Erreur a la demande d'information sur (pdt,nor) : "); 1272 ISCRUTE(numdt); ISCRUTE(numo); 1273 ret = -1; continue; 1274 }; 1275 1276 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); 1277 1278 printf("\tLe maillage par defaut est : |%s|, sur un total de : %i maillages associes\n", 1279 maa_ass, nbrefmaa); 1280 1281 /* Le maillage reference est-il porte par un autre fichier */ 1282 if ( !local ) { 1283 1284 if ( (lnsize=MEDnValLien(fid,maa_ass) ) < 0 ) { 1285 MESSAGE("Erreur a la lecture de la taille du lien : "); 1286 SSCRUTE(maa_ass); 1287 ret = -1; 1288 } else { 1289 1290 lien = malloc(lnsize*sizeof(char)); 1291 EXIT_IF(lien == NULL,NULL,NULL); 1292 1293 if ( MEDlienLire(fid, lien, maa_ass) < 0 ) { 1294 MESSAGE("Erreur a la lecture du lien : "); 1295 SSCRUTE(maa_ass);SSCRUTE(lien); 1296 ret = -1; 1297 } else { 1298 printf("\tLe maillage |%s| est porte par un fichier distant |%s|\n",maa_ass,lien); 1299 } 1300 free(lien); 1301 } 1302 } 1303 1304 /* Combien de maillages lies aux (nomcha,ent,geo,numdt,numo) */ 1305 /* Notons que cette information est egalement disponible a partir de MEDpasdetempsInfo */ 1306 if ( (nbrefmaa = MEDnChampRef(fid,nomcha,entite,type_geo[k],numdt,numo) ) < 0 ) { 1307 MESSAGE("Erreur a la demande du nombre de maillages references par le champ : "); 1308 SSCRUTE(nomcha); ISCRUTE(numdt); ISCRUTE(numo); 1309 ret = -1; continue; 1310 }; 1311 1312 for (l=0;l<nbrefmaa;l++) { 1313 1314 if ( MEDchampRefInfo(fid,nomcha,entite,type_geo[k], 1315 l+1,numdt, numo, maa_ass, &local, &ngauss) <0 ) { 1316 MESSAGE("Erreur a la demande d'information sur le maillage utilise par le champ n° : "); 1317 ISCRUTE(l+1); 1318 ret = -1; continue; 1319 }; 1320 1321 /* Prend en compte le nbre de pt de gauss automatiquement */ 1322 if ((nval = MEDnVal(fid,nomcha,entite,type_geo[k],numdt,numo,maa_ass,USER_MODE)) <= 0) { 1323 MESSAGE("Erreur a la lecture du nombre de valeurs du champ : "); 1324 SSCRUTE(nomcha);ISCRUTE(entite);ISCRUTE(type_geo[k]); 1325 ISCRUTE(numdt);ISCRUTE(numo);SSCRUTE(maa_ass);ISCRUTE(USER_MODE); 1326 ret = -1; continue; 1327 }; 1328 1329 1330 printf("\t- Il y a %d valeurs en mode %i. Chaque entite %s\ 1331 de type geometrique %s associes au maillage |%s| a %i pts de gauss \n", 1332 nval,USER_MODE,MED_ENTITE_MAILLAGE_AFF[(int)entite],AFF[k],maa_ass,ngauss); 1333 1334 /* Le maillage reference est-il porte par un autre fichier */ 1335 if ( !local ) { 1336 1337 if ( (lnsize=MEDnValLien(fid,maa_ass) ) < 0 ) { 1338 MESSAGE("Erreur a la lecture de la taille du lien : "); 1339 SSCRUTE(maa_ass); 1340 ret = -1; 1341 } else { 1342 1343 lien = malloc(lnsize*sizeof(char)); 1344 EXIT_IF(lien == NULL,NULL,NULL); 1345 1346 if ( MEDlienLire(fid, lien, maa_ass) < 0 ) { 1347 MESSAGE("Erreur a la lecture du lien : "); 1348 SSCRUTE(maa_ass);SSCRUTE(lien); 1349 ret = -1; 1350 } else { 1351 printf("\tLe maillage |%s| est porte par un fichier distant |%s|\n",maa_ass,lien); 1352 } 1353 free(lien); 1354 } 1355 } 1356 1357 /*Lecture des valeurs du champ */ 1358 if (typcha == MED_FLOAT64) { 1359 1360 valr = (med_float*) calloc(ncomp*nval,sizeof(med_float)); 1361 EXIT_IF(valr == NULL,NULL,NULL); 1362 if ( MEDchampLire(fid,maa_ass,nomcha,(unsigned char*)valr,stockage,MED_ALL,locname, 1363 pflname,USER_MODE,entite,type_geo[k],numdt,numo) < 0 ) { 1364 MESSAGE("Erreur a la lecture du nombre de valeurs du champ : "); 1365 SSCRUTE(nomcha);ISCRUTE(entite);ISCRUTE(type_geo[k]); 1366 ISCRUTE(numdt);ISCRUTE(numo);SSCRUTE(maa_ass); 1367 ret = -1; 1368 }; 1369 1370 } else { 1371 1372 vale = (med_int*) calloc(ncomp*nval,sizeof(med_int)); 1373 EXIT_IF(vale == NULL,NULL,NULL); 1374 if ( MEDchampLire(fid,maa_ass,nomcha,(unsigned char*)vale,stockage,MED_ALL,locname, 1375 pflname,USER_MODE,entite,type_geo[k],numdt,numo) < 0 ) { 1376 MESSAGE("Erreur a la lecture des valeurs du champ : "); 1377 SSCRUTE(nomcha);ISCRUTE(entite);ISCRUTE(type_geo[k]); 1378 ISCRUTE(numdt);ISCRUTE(numo);SSCRUTE(maa_ass); 1379 ret = -1; 1380 }; 1381 1382 } 1383 1384 switch (stockage) { 1385 1386 case MED_FULL_INTERLACE : 1387 printf("\t- Valeurs :\n\t"); 1388 for (m=0;m<nval/ngauss;m++) { 1389 printf("|"); 1390 for (n=0;n<ngauss*ncomp;n++) 1391 if (typcha == MED_FLOAT64) 1392 printf(" %f ",*(valr+(m*ngauss*ncomp)+n)); 1393 else 1394 printf(" %d ",*(vale+(m*ngauss*ncomp)+n)); 1395 1396 } 1397 break; 1398 1399 case MED_NO_INTERLACE : 1400 printf("\t- Valeurs :\n\t"); 1401 for (m=0;m<ncomp;m++) { 1402 printf("|"); 1403 for (n=0;n<nval;n++) 1404 if (typcha == MED_FLOAT64) 1405 printf(" %f ",*(valr+(m*nval)+n)); 1406 else 1407 printf(" %d ",*(vale+(m*nval)+n)); 1408 } 1409 break; 1410 } 1411 1412 printf("|\n"); 1413 if (typcha == MED_FLOAT64) { 1414 if ( valr ) {free(valr);valr = NULL;}} 1415 else 1416 if (vale) { free(vale);vale = NULL; } 1417 1418 /*Lecture du profil associe */ 1419 if (strcmp(pflname,MED_NOPFL) == 0 ) 1420 printf("\t- Profil : MED_NOPFL\n"); 1421 else { 1422 1423 if ( (pflsize = MEDnValProfil(fid,pflname)) <0 ) { 1424 MESSAGE("Erreur a la lecture du nombre de valeurs du profil : "); 1425 SSCRUTE(pflname); 1426 ret = -1; continue; 1427 } 1428 1429 printf("\t- Profil : |%s| de taille %i\n",pflname,pflsize); 1430 1431 pflval = (med_int*) malloc(sizeof(med_int)*pflsize); 1432 EXIT_IF(pflval == NULL,NULL,NULL); 1433 if ( MEDprofilLire(fid,pflval,pflname) <0) { 1434 MESSAGE("Erreur a la lecture des valeurs du profil : "); 1435 SSCRUTE(pflname); 1436 ret = -1; 1437 } 1438 printf("\t"); 1439 for (m=0;m<pflsize;m++) printf(" %i ",*(pflval+m)); 1440 printf("\n"); 1441 free(pflval); 1442 1443 } 1444 1445 } 1446 } 1447 } /* fin for sur les mailles*/ 1448 1449 return ret; 1450 } 1451 1452 /****************************************************************************** 1453 * 1454 * - Nom de la fonction : lecture_resultats 1455 * - Description : lecture et affichage des champs de resultats 1456 * associe a un maillage MED. 1457 * - Parametres : 1458 * - fid (IN) : ID du fichier MED. 1459 * - mdim (IN) : dimension du maillage. 1460 * - mode_coo (IN) : mode de stockage en memoire : 1461 * MED_FULL_INTERLACE | MED_NO_INTERLACE. 1462 * - lecture_en_tete_seulement (IN) : mode de lecture. 1463 * 1464 ******************************************************************************/ 1465 1466 void lecture_resultats(med_idt fid, 1467 med_mode_switch mode_coo,int lecture_en_tete_seulement) 1468 { 1469 med_err ret,lret; 1470 char pflname[MED_TAILLE_NOM+1]="",nomlien[MED_TAILLE_NOM+1]=""; 1471 char * lien = NULL; 1472 char *comp, *unit; 1473 char nomcha [MED_TAILLE_NOM+1]=""; 1474 char locname[MED_TAILLE_NOM+1]=""; 1475 med_int mdim,ncomp,ncha,npro,nln,pflsize,*pflval,nval,nloc,ngauss; 1476 med_type_champ typcha; 1477 med_maillage type; 1478 int t1,t2,t3; 1479 med_geometrie_element type_geo; 1480 med_float *refcoo, *gscoo, *wg; 1481 int i,j; 1482 1483 if (! lecture_en_tete_seulement) { 1484 fprintf(stdout,"\n(************************)\n"); 1485 fprintf(stdout,"(* CHAMPS DU MAILLAGE : *)\n"); 1486 fprintf(stdout,"(************************)\n"); 1487 } 1488 1489 /* combien de champs dans le fichier */ 1490 ncha = MEDnChamp(fid,0); 1491 EXIT_IF(ncha < 0,"lors de la lecture du nombre de champs",NULL); 1492 fprintf(stdout,"- Nombre de champs : %d \n",ncha); 1493 1494 if (lecture_en_tete_seulement) 1495 return; 1496 1497 /**************************************************************************** 1498 * LECTURE DES CHAMPS * 1499 ****************************************************************************/ 1500 ret = 0; 1501 1502 /* lecture de tous les champs */ 1503 for (i =0;i<ncha;i++) { 1504 lret = 0; 1505 printf("\nChamp numero : |%d| \n",i+1); 1506 1507 /* Lecture du nombre de composantes */ 1508 if ((ncomp = MEDnChamp(fid,i+1)) < 0) { 1509 MESSAGE("Erreur à la lecture du nombre de composantes : "); ISCRUTE(ncomp); 1510 ret = -1; continue; 1511 } 1512 1513 /* Lecture du type du champ, des noms des composantes et du nom de l'unité*/ 1514 comp = (char*) malloc(ncomp*MED_TAILLE_PNOM+1); 1515 EXIT_IF(comp == NULL,NULL,NULL); 1516 unit = (char*) malloc(ncomp*MED_TAILLE_PNOM+1); 1517 EXIT_IF(unit == NULL,NULL,NULL); 1518 1519 if ( MEDchampInfo(fid,i+1,nomcha,&typcha,comp,unit,ncomp) < 0 ) { 1520 MESSAGE("Erreur à la demande d'information sur les champs : "); 1521 ret = -1; continue; 1522 } 1523 1524 printf("Nom du champ : |%s| de type |%d|\n",nomcha,typcha); 1525 printf("Nom des composantes : |%s|\n",comp); 1526 printf("Unites des composantes : |%s| \n",unit); 1527 1528 free(comp); 1529 free(unit); 1530 1531 1532 lret = getFieldsOn(fid, nomcha, typcha, ncomp, MED_NOEUD,mode_coo); 1533 1534 if (lret == 0) lret = getFieldsOn(fid, nomcha, typcha, ncomp, MED_MAILLE,mode_coo); 1535 else { MESSAGE("Erreur à la lecture des champs aux noeuds "); ret = -1; continue;} 1536 1537 if (lret == 0) lret = getFieldsOn(fid, nomcha, typcha, ncomp, MED_FACE,mode_coo); 1538 else { MESSAGE("Erreur à la lecture des champs aux mailles "); ret = -1; continue;} 1539 1540 if (lret == 0) lret = getFieldsOn(fid, nomcha, typcha, ncomp, MED_ARETE,mode_coo); 1541 else {MESSAGE("Erreur à la lecture des champs aux faces "); ret = -1; continue;} 1542 1543 if (lret != 0) {MESSAGE("Erreur à la lecture des champs aux aretes "); ret = -1;}; 1544 } 1545 1546 1547 /* Interrogation des profils */ 1548 npro = MEDnProfil(fid); 1549 1550 printf("\nNombre de profils stockes : %i\n\n",npro); 1551 for (i=1 ; i <= npro ; i++ ) { 1552 if ( MEDprofilInfo(fid, i, pflname, &nval) < 0) { 1553 MESSAGE("Erreur a la demande d'information sur le profil n° : "); ISCRUTE(i); 1554 ret = -1;continue; 1555 } 1556 printf("\t- Profil n°%i de nom |%s| et de taille %i\n",i,pflname,nval); 1557 pflval = (med_int*) malloc(sizeof(med_int)*nval); 1558 if ( MEDprofilLire(fid, pflval, pflname) < 0) { 1559 MESSAGE("Erreur a la lecture des valeurs du profil : "); 1560 SSCRUTE(pflname); 1561 ret = -1; 1562 } else { 1563 printf("\t"); 1564 for (j=0;j<nval;j++) printf(" %i ",*(pflval+j)); 1565 printf("\n\n"); 1566 } 1567 free(pflval); 1568 } 1569 1570 /* Interrogation des liens */ 1571 nln = MEDnLien(fid); 1572 1573 printf("\nNombre de liens stockes : %i\n\n",nln); 1574 for (i=1 ; i <= nln ; i++ ) { 1575 if ( MEDlienInfo(fid, i, nomlien, &nval) < 0) { 1576 MESSAGE("Erreur a la demande d'information sur le lien n° : "); ISCRUTE(i); 1577 ret = -1;continue; 1578 } 1579 printf("\t- Lien n°%i de nom |%s| et de taille %i\n",i,nomlien,nval); 1580 1581 lien = malloc(nval*sizeof(char)); 1582 EXIT_IF(lien == NULL,NULL,NULL); 1583 1584 if ( MEDlienLire(fid, lien, nomlien) < 0 ) { 1585 MESSAGE("Erreur a la lecture du lien : "); 1586 SSCRUTE(nomlien);SSCRUTE(lien); 1587 ret = -1; 1588 } else 1589 printf("\t\t|%s|\n\n",lien); 1590 free(lien); 1591 } 1592 1593 /* Interrogation des localisations des points de GAUSS */ 1594 nloc = MEDnGauss(fid); 1595 1596 printf("\nNombre de localisations stockees : %i\n\n",nloc); 1597 for (i=1 ; i <= nloc ; i++ ) { 1598 if ( MEDgaussInfo(fid, i, locname, &type_geo, &ngauss) < 0) { 1599 MESSAGE("Erreur a la demande d'information sur la localisation n° : "); ISCRUTE(i); 1600 ret = -1;continue; 1601 } 1602 printf("\t- Loc. n°%i de nom |%s| et nbr. de pts de GAUSS %i\n",i,locname,ngauss); 1603 t1 = (type_geo%100)*(type_geo/100); 1604 t2 = ngauss*(type_geo/100); 1605 t3 = ngauss; 1606 refcoo = (med_float *) malloc(sizeof(med_float)*t1 ); 1607 gscoo = (med_float *) malloc(sizeof(med_float)*t2 ); 1608 wg = (med_float *) malloc(sizeof(med_float)*t3 ); 1609 1610 if ( MEDgaussLire(fid, refcoo, gscoo, wg, mode_coo, locname ) < 0) { 1611 MESSAGE("Erreur a la lecture des valeurs de la localisation : "); 1612 SSCRUTE(locname); 1613 ret = -1; 1614 } else { 1615 printf("\t Coordonnees de l'element de reference de type %i :\n\t\t",type_geo); 1616 for (j=0;j<t1;j++) printf(" %f ",*(refcoo+j)); 1617 printf("\n"); 1618 printf("\t Localisation des points de GAUSS : \n\t\t"); 1619 for (j=0;j<t2;j++) printf(" %f ",*(gscoo+j)); 1620 printf("\n"); 1621 printf("\t Poids associes aux points de GAUSS :\n\t\t"); 1622 for (j=0;j<t3;j++) printf(" %f ",*(wg+j)); 1623 printf("\n\n"); 1624 } 1625 free(refcoo); 1626 free(gscoo); 1627 free(wg); 1628 } 1629 1630 return; 1631 } 1632 1633 /****************************************************************************** 1634 * 1635 * - Nom de la fonction : lecture_parametres_scalaires 1636 * - Description : lecture des parametres scalaires definis 1637 * hors champs et maillages. 1638 * - Parametres : 1639 * - fid (IN) : ID du fichier MED. 1640 * - lecture_en_tete_seule (IN) : mode de lecture. 1641 * 1642 ******************************************************************************/ 1643 1644 void lecture_parametres_scalaires(med_idt fid,int lecture_en_tete_seulement) 1645 { 1646 med_err ret = 0; 1647 char nom_scalaire[MED_TAILLE_NOM+1]; 1648 char description[MED_TAILLE_DESC+1]; 1649 med_int vali; 1650 med_float valr; 1651 med_int i,n,npdt,j; 1652 med_type_champ type; 1653 med_int numdt,numo; 1654 med_float dt; 1655 char dt_unit[MED_TAILLE_PNOM+1]; 1656 1657 fprintf(stdout,"\n(*******************************)\n"); 1658 fprintf(stdout,"(* SCALAIRES HORS MODELE MED : *)\n"); 1659 fprintf(stdout,"(*******************************)\n"); 1660 1661 /* Combien de variables scalaire ? */ 1662 n = MEDnScalaire(fid); 1663 EXIT_IF(n < 0,"lors de la lecture du nombre de scalaires",NULL); 1664 fprintf(stdout,"- Nombre de variables scalaires : %d\n",n); 1665 1666 if (lecture_en_tete_seulement) 1667 return ; 1668 1669 for (i=1;i<=n;i++) { 1670 1671 /* Lecture des infos (type,description) */ 1672 ret = MEDscalaireInfo(fid,i,nom_scalaire,&type,description); 1673 EXIT_IF(ret < 0,"lors de la lecture des parametres d'un scalaire",NULL); 1674 printf("- Scalaire n°%d de nom %s \n",i,nom_scalaire); 1675 if (type == MED_FLOAT64) 1676 printf(" Type flottant. \n"); 1677 else 1678 printf(" Type entier. \n"); 1679 printf(" Description associee : [%s] \n",description); 1680 1681 /* Pour chaque scalaire on regarde les valeurs associees 1682 eventuellement a des pas de temps et des numeros d'ordre */ 1683 npdt = MEDnScalairePasdetemps(fid,nom_scalaire); 1684 EXIT_IF(npdt < 0,"lors de la lecture du nombre de pas de temps d'un scalaire",NULL); 1685 printf(" Nombre de valeurs stockees : %d \n",npdt); 1686 1687 for (j=1;j<=npdt;j++) { 1688 ret = MEDscalairePasdetempsInfo(fid,nom_scalaire,j, 1689 &numdt,dt_unit,&dt,&numo); 1690 EXIT_IF(ret < 0,"lors de la lecture des parametres d'un pas de temps d'un scalaire",NULL); 1691 1692 if (numdt == MED_NOPDT) 1693 printf(" - Aucun de pas de temps \n"); 1694 else 1695 printf(" - Pas de de temps de numero %d de valeur %f [%s] \n",numdt,dt,dt_unit); 1696 if (numo == MED_NONOR) 1697 printf(" - Aucun numero d'ordre \n"); 1698 else 1699 printf(" - Numero d'ordre : %d \n",numo); 1700 1701 if (type == MED_FLOAT64) 1702 ret = MEDscalaireFlottantLire(fid,nom_scalaire,&valr,numdt,numo); 1703 else 1704 ret = MEDscalaireEntierLire(fid,nom_scalaire,&vali,numdt,numo); 1705 EXIT_IF(ret < 0,"lors de la lecture de la valeur d'un scalaire",NULL); 1706 1707 } 1708 } 1709 1710 return ; 1711 } 1712 1713 1714 1715 /****************************************************************************** 1716 * 1717 * - Nom de la fonction : main 1718 * - Description : outil de DUMP d'un fichier MED. 1719 * - Parametres : 1720 * - argc (IN) : nombre d'arguments sur la ligne de commande. 1721 * - argv (IN) : liste des arguments. 1722 * 1723 ******************************************************************************/ 1724 1725 int main (int argc, char **argv) 1726 { 1727 med_err ret = 0; 1728 int reponse; 1729 med_idt fid; 1730 int i; 1731 int numero; 1732 med_mode_switch mode_coo; 1733 med_connectivite typ_con; 1734 int lecture_en_tete_seulement = 0; 1735 char nom_universel[MED_TAILLE_LNOM+1]; 1736 med_int long_fichier_en_tete; 1737 char *fichier_en_tete; 1738 char version_hdf[10]; 1739 char version_med[10]; 1740 med_int mdim,nmaa; 1741 /* nom du maillage */ 1742 char nommaa[MED_TAILLE_NOM+1]; 1743 char maillage_description[MED_TAILLE_DESC+1]; 1744 med_maillage type_maillage; 1745 med_int edim; 1746 med_int majeur,mineur,release; 1747 med_int majeur_lu,mineur_lu,release_lu; 1748 med_int nprofils; 1749 1750 1751 /**************************************************************************** 1752 * TEST DU NOMBRE D'ARGUMENTS * 1753 * argument 1 = nom du fichier MED * 1754 ****************************************************************************/ 1755 EXIT_IF(argc != 2 && argc != 5,"nombre de parametres incorrects\n",NULL); 1756 1757 /**************************************************************************** 1758 * OUVERTURE DU FICHIER EN LECTURE * 1759 ****************************************************************************/ 1760 1761 /* on regarde s'il s'agit d'un fichier au format HDF 5 */ 1762 ret = MEDformatConforme(argv[1]); 1763 EXIT_IF(ret < 0,"Le fichier n'est pas au format HDF V5 !!!",NULL); 1764 1765 /* Quelle version de MED est utilise par mdump ? */ 1766 MEDversionDonner(&majeur,&mineur,&release); 1767 fprintf(stdout,"- Lecture du fichier à l'aide de la bibliothèque MED-fichier V%d.%d.%d \n",majeur,mineur,release); 1768 1769 fid = MEDouvrir(argv[1],MED_LECTURE); 1770 EXIT_IF( fid < 0,"ouverture du du fichier ",argv[1]); 1771 1772 /**************************************************************************** 1773 * QUESTIONS PRELIMINAIRES * 1774 * 1. Mode d'affichage des coordonnees (entrelace ou non) ? * 1775 * 2. Connectivite des elements (nodale ou descendante) * 1776 ****************************************************************************/ 1777 fprintf(stdout,"\n >>>>>> DUMP DU FICHIER %s >>>>>>\n",argv[1]); 1778 1779 /* en-tete du fichier (presence optionnelle) */ 1780 long_fichier_en_tete = MEDlFichDes(fid); 1781 if (long_fichier_en_tete > 0) { 1782 fichier_en_tete = (char *) malloc(sizeof(char)*(long_fichier_en_tete+1)); 1783 EXIT_IF(fichier_en_tete == NULL,NULL,NULL); 1784 1785 /* on va lire dans le fichier */ 1786 ret = MEDfichEntete(fid,MED_FICH_DES,fichier_en_tete); 1787 if (ret < 0) 1788 free(fichier_en_tete); 1789 EXIT_IF(ret < 0,"lecture de l'en-tete du fichier",argv[1]); 1790 1791 /* on affiche */ 1792 fprintf(stdout,"- En-tete du fichier : %s \n",fichier_en_tete); 1793 free(fichier_en_tete); 1794 } 1795 1796 if (argc == 2) { 1797 fprintf(stdout,"(*****************)\n"); 1798 fprintf(stdout,"(* PARAMETRAGE : *)\n"); 1799 fprintf(stdout,"(*****************)\n"); 1800 fprintf(stdout,"- Mode d'affichage des coordonnées des noeuds ? \n"); 1801 fprintf(stdout," 1. Mode entrelacé : taper 1 \n"); 1802 fprintf(stdout," 2. Mode non entrelacé : taper 2 \n"); 1803 reponse = 0; 1804 do { 1805 fprintf(stdout," Reponse : "); 1806 scanf("%d",&reponse); 1807 } while (reponse != 1 && reponse != 2); 1808 if (reponse == 1) 1809 mode_coo = MED_FULL_INTERLACE; 1810 else 1811 mode_coo = MED_NO_INTERLACE; 1812 1813 fprintf(stdout,"- Connectivité des éléments ? \n"); 1814 fprintf(stdout," 1. Nodale : taper 1 \n"); 1815 fprintf(stdout," 2. Descendante : taper 2 \n"); 1816 reponse = 0; 1817 do { 1818 fprintf(stdout," Reponse : "); 1819 scanf("%d",&reponse); 1820 } while (reponse != 1 && reponse != 2); 1821 if (reponse == 1) 1822 typ_con = MED_NOD; 1823 else 1824 typ_con = MED_DESC; 1825 } 1826 else { 1827 if (! strcmp(argv[3],"NODALE")) 1828 typ_con = MED_NOD; 1829 if (! strcmp(argv[3],"DESCENDANTE")) 1830 typ_con = MED_DESC; 1831 1832 if (!strcmp(argv[4],"NO_INTERLACE")) 1833 mode_coo = MED_NO_INTERLACE; 1834 if (!strcmp(argv[4],"FULL_INTERLACE")) 1835 mode_coo = MED_FULL_INTERLACE; 1836 if (! strcmp(argv[4],"LECTURE_EN_TETE_SEULEMENT")) 1837 lecture_en_tete_seulement = 1; 1838 1839 } 1840 1841 /**************************************************************************** 1842 * QUEL MAILLAGE LIRE * 1843 ****************************************************************************/ 1844 nmaa = MEDnMaa(fid); 1845 EXIT_IF(nmaa < 0,"lors de la lecture du nombre de maillages",NULL); 1846 1847 /* Quel maillage lire ? */ 1848 if (argc == 2) { 1849 fprintf(stdout,"- Il y a %d maillages dans ce fichier \n",nmaa); 1850 fprintf(stdout," Lequel voulez-vous lire (1|2|3|...|n) ?\n"); 1851 do { 1852 fprintf(stdout," Reponse : "); 1853 scanf("%d",&numero); 1854 } while (numero > nmaa || numero <= 0); 1855 } 1856 else { 1857 numero = atoi(argv[2]); 1858 EXIT_IF(numero > nmaa || numero <= 0,"ce numero de maillage n'existe pas",NULL); 1859 } 1860 1861 /**************************************************************************** 1862 * PARAMETRES SCALAIRES HORS MODELE MED * 1863 ****************************************************************************/ 1864 1865 /* on va lire l'ensemble des parametres scalaire */ 1866 lecture_parametres_scalaires(fid,lecture_en_tete_seulement); 1867 1868 /**************************************************************************** 1869 * INFOS GENERALES SUR LE MAILLAGE * 1870 ****************************************************************************/ 1871 fprintf(stdout,"\n(********************************************)\n"); 1872 fprintf(stdout,"(* INFORMATIONS GENERALES SUR LE MAILLAGE : *)\n"); 1873 fprintf(stdout,"(********************************************)\n"); 1874 1875 /* lecture du nom et de la dimension du maillage */ 1876 ret = MEDmaaInfo(fid,numero,nommaa,&mdim,&type_maillage,maillage_description); 1877 EXIT_IF(ret < 0,"Lecture des informations sur le maillage",NULL); 1878 edim = MEDdimEspaceLire(fid,nommaa); 1879 fprintf(stdout,"- Nom du maillage : <<%s>>\n",nommaa); 1880 fprintf(stdout,"- Dimension du maillage : %d\n",mdim); 1881 if (edim > mdim) 1882 fprintf(stdout,"- La dimension de l'espace est %d \n",edim); 1883 if (type_maillage == MED_NON_STRUCTURE) 1884 fprintf(stdout,"- Type du maillage : MED_NON_STRUCTURE \n"); 1885 else 1886 fprintf(stdout,"- Type du maillage : MED_STRUCTURE \n"); 1887 fprintf(stdout,"- Description associee au maillage : %s\n",maillage_description); 1888 1889 /* lecture du nom universel (presence optionnelle) */ 1890 ret = MEDunvLire(fid,nommaa,nom_universel); 1891 if (ret == 0) 1892 fprintf(stdout,"- Nom universel du maillage : %s \n",nom_universel); 1893 else 1894 fprintf(stdout,"- Pas de nom universel \n"); 1895 1896 1897 /**************************************************************************** 1898 * LECTURE DU MAILLAGE ET DES RESULTATS ASSOCIES * 1899 ****************************************************************************/ 1900 1901 /* en fonction du type du maillage */ 1902 if (type_maillage == MED_NON_STRUCTURE) 1903 lecture_maillage_non_structure(fid,nommaa,mdim,mode_coo,typ_con, 1904 lecture_en_tete_seulement); 1905 else 1906 lecture_maillage_structure(fid,nommaa,mdim,mode_coo, 1907 lecture_en_tete_seulement); 1908 1909 /* on lit ensuite les resultats */ 1910 lecture_resultats(fid,mode_coo,lecture_en_tete_seulement); 1911 1912 /**************************************************************************** 1913 * FERMETURE DU FICHIER * 1914 ****************************************************************************/ 1915 ret = MEDfermer(fid); 1916 EXIT_IF(ret < 0,"lors de la fermeture du fichier",argv[1]); 1917 1918 fprintf(stdout,"\n >>>>>> FIN DU DUMP DU FICHIER %s >>>>>>\n",argv[1]); 1919 1920 return EXIT_SUCCESS; 1921 }