1 /**************************************************************************** 2 * COPYRIGHT (C) 1999 - 2007 EDF R&D, CEA/DEN 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 23 * Ce fichier contient les fonctions suivantes 24 * qui constituent des modeles de programmation 25 * pour une lecture generique d'un fichier MED : 26 * - lecture_maillage_non_structure () : 27 * 1. Noeuds. 28 * 2. Mailles. 29 * 3. Faces (connectivite descendante). 30 * 4. Aretes (connectivite descendante). 31 * 5. Familles. 32 * 6. Equivalences. 33 * 7. Joints. 34 * - lecture_maillage_structure () : 35 * 1. Noeuds. 36 * 2. Mailles. 37 * 3. Familles. 38 * 4. Equivalences. 39 * 5. Joints. 40 * - lecture_resultats () : 41 * 1. Champs de resultats relatifs à un maillage. 42 * - Entites : 43 * - Noeuds 44 * - Mailles 45 * - Faces 46 * - Aretes 47 * - Gestion des pas de temps et numeros d'ordre : 48 * valeurs associees a un ou plusieurs maillages sous 49 * un meme pas de temps. 50 * - Gestion des profils. 51 * - Gestion des liens vers des maillages distants 52 * - Gestion des points de Gauss : 53 * - localisation des points de Gauss. 54 * - lecture_parametres_scalaires () : 55 * - Valeurs scalaires entieres ou flottantes. 56 * - Gestion des pas de temps et numeros d'ordre. 57 * - main() : infos generales + lecture de tous les champs et 58 * du fichier MED passe en parametre. 59 * 60 *****************************************************************************/ 61 62 #define MESGERR 63 64 #ifdef __cplusplus 65 extern "C" { 66 #endif 67 68 #include <med.h> 69 #include <med_config.h> 70 #include <med_utils.h> 71 #include <med_misc.h> 72 #include <stdio.h> 73 #include <string.h> 74 #include <stdlib.h> 75 76 #ifdef __cplusplus 77 } 78 #endif 79 80 #ifdef PPRO_NT 81 #define F_OK 0 82 #else 83 #include <unistd.h> 84 #endif 85 86 /* indique si on ecrit seulement la structure */ 87 int structure = 0; 88 89 /* types geometriques des mailles references dans le modele MED */ 90 med_geometrie_element typmai[MED_NBR_GEOMETRIE_MAILLE] = { MED_POINT1, 91 MED_SEG2, 92 MED_SEG3, 93 MED_TRIA3, 94 MED_TRIA6, 95 MED_QUAD4, 96 MED_QUAD8, 97 MED_TETRA4, 98 MED_TETRA10, 99 MED_HEXA8, 100 MED_HEXA20, 101 MED_PENTA6, 102 MED_PENTA15, 103 MED_PYRA5, 104 MED_PYRA13}; 105 char nommai[MED_NBR_GEOMETRIE_MAILLE] [MED_TAILLE_NOM+1] = {"MED_POINT1", 106 "MED_SEG2", 107 "MED_SEG3", 108 "MED_TRIA3", 109 "MED_TRIA6", 110 "MED_QUAD4", 111 "MED_QUAD8", 112 "MED_TETRA4", 113 "MED_TETRA10", 114 "MED_HEXA8", 115 "MED_HEXA20", 116 "MED_PENTA6", 117 "MED_PENTA15", 118 "MED_PYRA5", 119 "MED_PYRA13"}; 120 med_geometrie_element typfac[MED_NBR_GEOMETRIE_FACE] = {MED_TRIA3, 121 MED_TRIA6, 122 MED_QUAD4, 123 MED_QUAD8}; 124 char nomfac[MED_NBR_GEOMETRIE_FACE][MED_TAILLE_NOM+1] = {"MED_TRIA3", 125 "MED_TRIA6", 126 "MED_QUAD4", 127 "MED_QUAD8"}; 128 med_geometrie_element typare[MED_NBR_GEOMETRIE_ARETE] = {MED_SEG2, 129 MED_SEG3}; 130 char nomare[MED_NBR_GEOMETRIE_ARETE] [MED_TAILLE_NOM+1] = {"MED_SEG2", 131 "MED_SEG3"}; 132 133 #define USER_MODE MED_COMPACT 134 135 med_int lecture_nombre_famille(med_idt fid,char *nommaa) 136 { 137 med_int nfam = MEDnFam(fid,nommaa); 138 EXIT_IF(nfam < 0,"lors de la lecture du nombre de familles",NULL); 139 fprintf(stdout,"- Nombre de familles : %d \n",nfam); 140 141 return nfam; 142 } 143 144 void lecture_famille_maillage(med_idt fid,char *nommaa,med_int nfam) 145 { 146 med_int i,j; 147 med_int natt,ngro; 148 char *attdes,*gro; 149 med_int *attval,*attide; 150 char nomfam[MED_TAILLE_NOM+1]; 151 med_int numfam; 152 char str1[MED_TAILLE_DESC+1]; 153 char str2[MED_TAILLE_LNOM+1]; 154 med_err ret = 0; 155 int famille_0 = 0; 156 157 fprintf(stdout,"\n(**************************)\n"); 158 fprintf(stdout,"(* FAMILLES DU MAILLAGE : *)\n"); 159 fprintf(stdout,"(**************************)\n"); 160 161 for (i=0;i<nfam;i++) { 162 163 /* nombre de groupes */ 164 ngro = MEDnGroupe(fid,nommaa,i+1); 165 EXIT_IF(ngro < 0,"lors de la lecture du nombre de groupe d'une famille", 166 NULL); 167 168 /* nombre d'attributs */ 169 natt = MEDnAttribut(fid,nommaa,i+1); 170 EXIT_IF(natt < 0,"lors de la lecture du nombre d'attributs d'une famille", 171 NULL); 172 173 fprintf(stdout,"- Famille %d a %d attributs et %d groupes \n",i+1,natt, 174 ngro); 175 176 /* nom,numero,attributs,groupes */ 177 178 /* allocation memoire */ 179 attide = (med_int*) malloc(sizeof(med_int)*natt); 180 EXIT_IF(attide == NULL,NULL,NULL); 181 attval = (med_int*) malloc(sizeof(med_int)*natt); 182 EXIT_IF(attval == NULL,NULL,NULL); 183 attdes = (char *) malloc(MED_TAILLE_DESC*natt+1); 184 EXIT_IF(attdes == NULL,NULL,NULL); 185 gro = (char*) malloc(MED_TAILLE_LNOM*ngro+1); 186 EXIT_IF(gro == NULL,NULL,NULL); 187 188 ret = MEDfamInfo(fid,nommaa,i+1,nomfam,&numfam,attide,attval, 189 attdes,&natt,gro,&ngro); 190 EXIT_IF(ret < 0,"lors de la lecture des informations d'une famille", 191 NULL); 192 if (numfam == 0) 193 famille_0 = 1; 194 195 if (!structure) { 196 /* affichage des resultats */ 197 fprintf(stdout," - Famille de nom %s et de numero %d : \n",nomfam,numfam); 198 fprintf(stdout," - Attributs : \n"); 199 for (j=0;j<natt;j++) { 200 strncpy(str1,attdes+j*MED_TAILLE_DESC,MED_TAILLE_DESC); 201 str1[MED_TAILLE_DESC] = '\0'; 202 fprintf(stdout," ide = %d - val = %d - des = %s\n",*(attide+j), 203 *(attval+j),str1); 204 } 205 } 206 207 /* on libere la memoire */ 208 free(attide); 209 free(attval); 210 free(attdes); 211 212 if (!structure) { 213 fprintf(stdout," - Groupes :\n"); 214 for (j=0;j<ngro;j++) { 215 strncpy(str2,gro+j*MED_TAILLE_LNOM,MED_TAILLE_LNOM); 216 str2[MED_TAILLE_LNOM] = '\0'; 217 fprintf(stdout," gro = %s\n",str2); 218 } 219 } 220 221 /* on libere la memoire */ 222 free(gro); 223 } 224 EXIT_IF(famille_0 != 1,"Pas de famille de numéro 0", 225 NULL); 226 227 return; 228 } 229 230 med_int lecture_nombre_equivalence(med_idt fid,char *nommaa) 231 { 232 med_int nequ = MEDnEquiv(fid,nommaa); 233 EXIT_IF(nequ < 0,"lors de la lecture du nombre d'equivalences",NULL); 234 fprintf(stdout,"- Nombre d'equivalences : %d \n",nequ); 235 236 return nequ; 237 } 238 239 /* nombre de mailles concernees par les equivalences */ 240 #define NBR_MAILLE_EQU 7 241 void lecture_equivalence_maillage(med_idt fid,char *nommaa,med_int nequ) 242 { 243 med_int i,j,k; 244 med_int ncor; 245 med_int *cor; 246 char equ[MED_TAILLE_NOM+1]; 247 char des[MED_TAILLE_DESC+1]; 248 med_int desmai[MED_NBR_GEOMETRIE_MAILLE] = {0,2,3,3,3,4,4,4,4,6,6,5,5,5,5}; 249 med_int nmailles[MED_NBR_GEOMETRIE_MAILLE]; 250 med_int desfac[MED_NBR_GEOMETRIE_FACE] = {3,3,4,4}; 251 med_int nfaces[MED_NBR_GEOMETRIE_FACE]; 252 med_int desare[MED_NBR_GEOMETRIE_ARETE] = {2,3}; 253 med_int naretes[MED_NBR_GEOMETRIE_ARETE]; 254 med_err ret = 0; 255 256 fprintf(stdout,"\n(******************************)\n"); 257 fprintf(stdout,"(* EQUIVALENCES DU MAILLAGE : *)\n"); 258 fprintf(stdout,"(******************************)\n"); 259 260 if (nequ == 0) 261 fprintf(stdout,"- Aucune équivalence \n"); 262 263 /* lecture de toutes les equivalences associes a nommaa */ 264 for (i = 0;i<nequ;i++) { 265 fprintf(stdout,"- Equivalence numero : %d ",i+1); 266 267 /* lecture des infos sur l'equivalence */ 268 ret = MEDequivInfo(fid,nommaa,i+1,equ,des); 269 EXIT_IF(ret < 0,"lors de la lecture des informations sur une equivalence", 270 NULL); 271 fprintf(stdout,"\n - Nom de l'equivalence: %s \n",equ); 272 fprintf(stdout,"\n - Description de l'equivalence : %s \n",des); 273 274 /* lecture des correspondances sur les differents types d'entites */ 275 276 /* les noeuds */ 277 ncor = MEDnCorres(fid,nommaa,equ,MED_NOEUD,(med_geometrie_element)0); 278 EXIT_IF(ncor < 0, 279 "lors de la lecture du nombre de correspondances d'une equivalence", 280 NULL); 281 fprintf(stdout,"\n - Il y a %d correspondances sur les noeuds \n",ncor); 282 283 if (ncor > 0) { 284 285 /* allocation memoire */ 286 cor = (med_int*) malloc(sizeof(med_int)*ncor*2); 287 EXIT_IF(cor == NULL,NULL,NULL); 288 289 ret = MEDequivLire(fid,nommaa,equ,cor,ncor,MED_NOEUD,(med_geometrie_element)0); 290 EXIT_IF(ret < 0,"lors de la lecture du tableau des correspondances", 291 NULL); 292 if (!structure) { 293 for (j=0;j<ncor;j++) 294 fprintf(stdout,"\n - Correspondance %d : %d et %d \n",j+1,*(cor+2*j), 295 *(cor+2*j+1)); 296 } 297 free(cor); 298 } 299 300 /* sur les mailles : on ne prend pas en compte les mailles 3D */ 301 for (j=0;j<NBR_MAILLE_EQU;j++) { 302 303 ncor = MEDnCorres(fid,nommaa,equ,MED_MAILLE,typmai[j]); 304 EXIT_IF(ncor < 0, 305 "lors de la lecture du nombre de correspondances dans une equivalence", 306 NULL); 307 fprintf(stdout,"\n - Il y a %d correspondances sur les mailles %s \n",ncor, 308 nommai[j]); 309 310 if (ncor > 0) { 311 312 /* allocation memoire */ 313 cor = (med_int*) malloc(sizeof(med_int)*ncor*2); 314 EXIT_IF(cor == NULL,NULL,NULL); 315 316 ret = MEDequivLire(fid,nommaa,equ,cor,ncor,MED_MAILLE, 317 typmai[j]); 318 EXIT_IF(ret < 0,"lors de la lecture du tableau des equivalences", 319 NULL); 320 321 if (!structure) { 322 for (k=0;k<ncor;k++) 323 fprintf(stdout,"\n - Correspondance %d : %d et %d \n",k+1, 324 *(cor+2*k),*(cor+2*k+1)); 325 } 326 327 free(cor); 328 } 329 } 330 331 /* sur les mailles Polygonales */ 332 333 ncor = MEDnCorres(fid,nommaa,equ,MED_MAILLE,MED_POLYGONE); 334 EXIT_IF(ncor < 0, 335 "lors de la lecture du nombre de correspondances dans une equivalence", 336 NULL); 337 fprintf(stdout,"\n - Il y a %d correspondances sur les mailles polygone \n",ncor); 338 339 if (ncor > 0) { 340 341 /* allocation memoire */ 342 cor = (med_int*) malloc(sizeof(med_int)*ncor*2); 343 EXIT_IF(cor == NULL,NULL,NULL); 344 345 ret = MEDequivLire(fid,nommaa,equ,cor,ncor,MED_MAILLE, 346 MED_POLYGONE); 347 EXIT_IF(ret < 0,"lors de la lecture du tableau des equivalences", 348 NULL); 349 350 if (!structure) { 351 for (k=0;k<ncor;k++) 352 fprintf(stdout,"\n - Correspondance %d : %d et %d \n",k+1, 353 *(cor+2*k),*(cor+2*k+1)); 354 } 355 356 free(cor); 357 } 358 359 360 /* sur les faces */ 361 for (j=0;j<MED_NBR_GEOMETRIE_FACE;j++) { 362 363 ncor = MEDnCorres(fid,nommaa,equ,MED_FACE,typfac[j]); 364 EXIT_IF(ncor < 0, 365 "lors de la lecture du nombre de correspondances dans une equivalence", 366 NULL); 367 fprintf(stdout,"\n - Il y a %d correspondances sur les faces %s\n",ncor, 368 nomfac[j]); 369 370 if (ncor > 0) { 371 372 /* allocation memoire */ 373 cor = (med_int*) malloc(sizeof(med_int)*ncor*2); 374 EXIT_IF(cor == NULL,NULL,NULL); 375 376 ret = MEDequivLire(fid,nommaa,equ,cor,ncor,MED_FACE, 377 typfac[j]); 378 EXIT_IF(ret < 0,"lors de la lecture du tableau des equivalences", 379 NULL); 380 381 if (!structure) { 382 for (k=0;k<ncor;k++) 383 fprintf(stdout,"\n - Correspondance %d : %d et %d \n",k+1,*(cor+2*k), 384 *(cor+2*k+1)); 385 } 386 387 free(cor); 388 } 389 } 390 391 /* sur les faces Polygonales */ 392 393 ncor = MEDnCorres(fid,nommaa,equ,MED_FACE,MED_POLYGONE); 394 EXIT_IF(ncor < 0, 395 "lors de la lecture du nombre de correspondances dans une equivalence", 396 NULL); 397 fprintf(stdout,"\n - Il y a %d correspondances sur les faces polygone \n",ncor); 398 399 if (ncor > 0) { 400 401 /* allocation memoire */ 402 cor = (med_int*) malloc(sizeof(med_int)*ncor*2); 403 EXIT_IF(cor == NULL,NULL,NULL); 404 405 ret = MEDequivLire(fid,nommaa,equ,cor,ncor,MED_FACE, 406 MED_POLYGONE); 407 EXIT_IF(ret < 0,"lors de la lecture du tableau des equivalences", 408 NULL); 409 410 if (!structure) { 411 for (k=0;k<ncor;k++) 412 fprintf(stdout,"\n - Correspondance %d : %d et %d \n",k+1,*(cor+2*k), 413 *(cor+2*k+1)); 414 } 415 416 free(cor); 417 } 418 419 /* sur les aretes */ 420 for (j=0;j<MED_NBR_GEOMETRIE_ARETE;j++) { 421 422 ncor = MEDnCorres(fid,nommaa,equ,MED_ARETE,typare[j]); 423 EXIT_IF(ncor < 0,"lors de la lecture du nombre de correspondances", 424 NULL); 425 fprintf(stdout,"\n - Il y a %d correspondances sur les aretes %s \n", 426 ncor,nomare[j]); 427 428 if (ncor > 0) { 429 430 /* allocation memoire */ 431 cor = (med_int*) malloc(sizeof(med_int)*ncor*2); 432 EXIT_IF(cor == NULL,NULL,NULL); 433 434 ret = MEDequivLire(fid,nommaa,equ,cor,ncor,MED_ARETE, 435 typare[j]); 436 EXIT_IF(ret < 0,"lors de la lecture du tableau des equivalences", 437 NULL); 438 439 if (!structure) { 440 for (k=0;k<ncor;k++) 441 fprintf(stdout,"\n Correspondance %d : %d et %d \n",k+1,*(cor+2*k), 442 *(cor+2*k+1)); 443 } 444 445 free(cor); 446 } 447 } 448 } 449 450 return; 451 } 452 453 454 med_int lecture_nombre_joint(med_idt fid,char *nommaa) 455 { 456 med_int njnt = MEDnJoint(fid,nommaa); 457 EXIT_IF(njnt < 0,"lors de la lecture du nombre de joints",NULL); 458 fprintf(stdout,"- Nombre de joints : %d \n",njnt); 459 460 return njnt; 461 } 462 463 464 void lecture_joint_maillage(med_idt fid,char *nommaa,med_int njnt) 465 { 466 med_int i,k; 467 char des[MED_TAILLE_DESC+1]; 468 med_int ndom,nent; 469 med_int typ_ent_local,typ_geo_local,typ_ent_distant,typ_geo_distant; 470 med_int geo_ent_local,geo_ent_distant; 471 472 char jn[MED_TAILLE_NOM+1]; 473 char maa_dist[MED_TAILLE_NOM+1]; 474 char corr[MED_TAILLE_NOM+1]; 475 med_int *cortab; 476 477 const med_int nb_geo_ent=1+NBR_MAILLE_EQU+1+MED_NBR_GEOMETRIE_ARETE+MED_NBR_GEOMETRIE_FACE+1; 478 med_geometrie_element typ_geo_ent[1+NBR_MAILLE_EQU+1+MED_NBR_GEOMETRIE_ARETE+MED_NBR_GEOMETRIE_FACE+1][2]= 479 { 480 {(med_geometrie_element)MED_NOEUD,(med_geometrie_element)0}, 481 {(med_geometrie_element)MED_MAILLE,MED_POINT1 }, 482 {(med_geometrie_element)MED_MAILLE,MED_SEG2 }, 483 {(med_geometrie_element)MED_MAILLE,MED_SEG3 }, 484 {(med_geometrie_element)MED_MAILLE,MED_TRIA3 }, 485 {(med_geometrie_element)MED_MAILLE,MED_TRIA6 }, 486 {(med_geometrie_element)MED_MAILLE,MED_QUAD4 }, 487 {(med_geometrie_element)MED_MAILLE,MED_QUAD8 }, 488 {(med_geometrie_element)MED_MAILLE,MED_POLYGONE }, 489 {(med_geometrie_element)MED_ARETE ,MED_SEG2 }, 490 {(med_geometrie_element)MED_ARETE ,MED_SEG3 }, 491 {(med_geometrie_element)MED_FACE ,MED_TRIA3 }, 492 {(med_geometrie_element)MED_FACE ,MED_TRIA6 }, 493 {(med_geometrie_element)MED_FACE ,MED_QUAD4 }, 494 {(med_geometrie_element)MED_FACE ,MED_QUAD8 }, 495 {(med_geometrie_element)MED_FACE ,MED_POLYGONE } 496 }; 497 char nom_geo_ent[1+NBR_MAILLE_EQU+1+MED_NBR_GEOMETRIE_ARETE+MED_NBR_GEOMETRIE_FACE+1][MED_TAILLE_NOM+1] = 498 { 499 "MED_NOEUD ", 500 "MED_MAILLE:MED_POINT1 ", 501 "MED_MAILLE:MED_SEG2 ", 502 "MED_MAILLE:MED_SEG3 ", 503 "MED_MAILLE:MED_TRIA3 ", 504 "MED_MAILLE:MED_TRIA6 ", 505 "MED_MAILLE:MED_QUAD4 ", 506 "MED_MAILLE:MED_QUAD8 ", 507 "MED_MAILLE:MED_POLYGONE ", 508 "MED_ARETE :MED_SEG2 ", 509 "MED_ARETE :MED_SEG3 ", 510 "MED_FACE :MED_TRIA3 ", 511 "MED_FACE :MED_TRIA6 ", 512 "MED_FACE :MED_QUAD4 ", 513 "MED_FACE :MED_QUAD8 ", 514 "MED_FACE :MED_POLYGONE " 515 }; 516 med_err ret = 0; 517 518 fprintf(stdout,"\n(******************************)\n"); 519 fprintf(stdout,"(* JOINTS DU MAILLAGE : *)\n"); 520 fprintf(stdout,"(******************************)\n"); 521 522 if (njnt == 0) 523 fprintf(stdout,"- Aucun joint \n"); 524 525 /* lecture de touts les joints associes a nommaa */ 526 for (i = 0;i<njnt;i++) { 527 fprintf(stdout,"- Joint numero : %d ",i+1); 528 529 /* lecture des infos sur le joint */ 530 ret=MEDjointInfo(fid,nommaa,i+1,jn,des,&ndom,maa_dist); 531 EXIT_IF(ret < 0,"lors de la lecture des informations sur un joint", 532 NULL); 533 fprintf(stdout,"\n - Nom du joint: %s \n",jn); 534 fprintf(stdout,"\n - Description du joint : %s ",des); 535 fprintf(stdout,"\n - Domaine en regard : %d ",ndom); 536 fprintf(stdout,"\n - Maillage distant : %s ",maa_dist); 537 538 539 /* lecture des correspondances sur les differents types d'entites */ 540 /* recherche du type des entites en regard... passage par toutes les combinaisons */ 541 for (geo_ent_local=0;geo_ent_local<nb_geo_ent;geo_ent_local++) { 542 for (geo_ent_distant=0;geo_ent_distant<nb_geo_ent;geo_ent_distant++) { 543 typ_ent_local = typ_geo_ent[geo_ent_local][0]; 544 typ_geo_local = typ_geo_ent[geo_ent_local][1]; 545 typ_ent_distant = typ_geo_ent[geo_ent_distant][0]; 546 typ_geo_distant = typ_geo_ent[geo_ent_distant][1]; 547 548 if (nent=MEDjointnCorres(fid,nommaa,jn,(med_entite_maillage)typ_ent_local,(med_geometrie_element)typ_geo_local, 549 (med_entite_maillage)typ_ent_distant,(med_geometrie_element)typ_geo_distant)) { 550 if (nent > 0) { 551 fprintf(stdout,"\n\t\t- nb de couples d'entites en regard (local,distant)=(%s,%s) : %d \n", 552 nom_geo_ent[geo_ent_local],nom_geo_ent[geo_ent_distant], 553 nent); 554 fprintf(stdout," %d \n",nent); 555 cortab = (med_int*) malloc(sizeof(med_int)*nent*2); 556 if (MEDjointLire(fid,nommaa,jn,cortab,nent*2, 557 (med_entite_maillage)typ_ent_local,(med_geometrie_element)typ_geo_local, 558 (med_entite_maillage)typ_ent_distant,(med_geometrie_element)typ_geo_distant) < 0) { 559 fprintf(stdout,"\n\t\t- Erreur a la lecture des correspondances sur (%d,%d,%d,%d)", 560 typ_ent_local,typ_geo_local,typ_ent_distant,typ_geo_distant,0); 561 } 562 else { 563 if (!structure) { 564 for (k=0;k<nent;k++) 565 fprintf(stdout,"\n\t\t- Correspondance %d : %d et %d ",k+1, 566 *(cortab+2*k),*(cortab+2*k+1)); 567 } 568 } 569 free(cortab); 570 } 571 572 } 573 } 574 } 575 } 576 577 return; 578 } 579 580 581 med_int lecture_nombre_noeuds_maillage_non_structure(med_idt fid, 582 char *nommaa) 583 { 584 med_int nnoe = MEDnEntMaa(fid,nommaa,MED_COOR,MED_NOEUD,(med_geometrie_element)0,(med_connectivite)0); 585 EXIT_IF(nnoe < 0,"lors de la lecture du nombre de noeuds",NULL); 586 fprintf(stdout,"- Nombre de noeuds : %d \n",nnoe); 587 588 return nnoe; 589 } 590 591 592 void lecture_noeuds_maillage_non_structure(med_idt fid, 593 char *nommaa, 594 med_int mdim, 595 med_int nnoe, 596 med_mode_switch mode_coo) 597 { 598 med_float *coo; 599 char nomcoo[3*MED_TAILLE_PNOM+1]; 600 char unicoo[3*MED_TAILLE_PNOM+1]; 601 char *nomnoe; 602 med_int *numnoe; 603 med_int *nufano; 604 med_repere rep; 605 med_booleen inonoe,inunoe; 606 med_err ret = 0; 607 med_int i; 608 char str[MED_TAILLE_PNOM+1]; 609 610 /* Allocations memoires */ 611 /* table des coordonnees 612 profil : (dimension * nombre de noeuds ) */ 613 coo = (med_float*) malloc(sizeof(med_float)*nnoe*mdim); 614 EXIT_IF(coo == NULL,NULL,NULL); 615 /* table des numeros, des numeros de familles des noeuds 616 profil : (nombre de noeuds) */ 617 numnoe = (med_int*) malloc(sizeof(med_int)*nnoe); 618 EXIT_IF(numnoe == NULL,NULL,NULL); 619 nufano = (med_int*) malloc(sizeof(med_int)*nnoe); 620 EXIT_IF(nufano == NULL,NULL,NULL); 621 /* table des noms des noeuds 622 profil : (nnoe*MED_TAILLE_PNOM+1) */ 623 nomnoe = (char*) malloc(MED_TAILLE_PNOM*nnoe+1); 624 EXIT_IF(nomnoe == NULL,NULL,NULL); 625 626 /* lecture des noeuds : 627 - coordonnees 628 - noms (optionnel dans un fichier MED) 629 - numeros (optionnel dans un fichier MED) 630 - numeros des familles */ 631 ret = MEDnoeudsLire(fid,nommaa,mdim,coo,mode_coo,&rep, 632 nomcoo,unicoo,nomnoe,&inonoe,numnoe,&inunoe, 633 nufano,nnoe); 634 EXIT_IF(ret < 0,"lors de la lecture des noeuds du maillage \n",NULL); 635 636 /* affichage des resultats */ 637 fprintf(stdout,"\n(************************)\n"); 638 fprintf(stdout,"(* NOEUDS DU MAILLAGE : *)\n"); 639 fprintf(stdout,"(************************)\n"); 640 fprintf(stdout,"- Type de repere des coordonnees : %d \n",rep); 641 fprintf(stdout,"- Nom des coordonnees : \n"); 642 for (i=0;i<mdim;i++) { 643 strncpy(str,nomcoo+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM); 644 str[MED_TAILLE_PNOM] = '\0'; 645 fprintf(stdout," %s ",str); 646 } 647 fprintf(stdout,"\n- Unites des coordonnees : \n"); 648 for (i=0;i<mdim;i++) { 649 strncpy(str,unicoo+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM); 650 str[MED_TAILLE_PNOM] = '\0'; 651 fprintf(stdout," %s ",str); 652 } 653 if (!structure) { 654 fprintf(stdout,"\n- Coordonnees des noeuds : \n"); 655 for (i=0;i<nnoe*mdim;i++) { 656 if (mode_coo == MED_FULL_INTERLACE && !(i % mdim)) 657 fprintf(stdout,"\n [ %5d ] : ", (i/mdim + 1) ); 658 if (mode_coo == MED_NO_INTERLACE && ! (i % nnoe)) 659 fprintf(stdout,"\n\n "); 660 fprintf(stdout," %-+9.6f ",*(coo+i)); 661 } 662 663 if (inonoe) { 664 fprintf(stdout,"\n- Noms des noeuds : \n"); 665 for (i=0;i<nnoe;i++) { 666 strncpy(str,nomnoe+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM); 667 str[MED_TAILLE_PNOM] = '\0'; 668 fprintf(stdout," %s ",str); 669 } 670 } 671 if (inunoe) { 672 fprintf(stdout,"\n- Numeros des noeuds : \n"); 673 for (i=0;i<nnoe;i++) 674 fprintf(stdout," %d ",*(numnoe+i)); 675 } 676 fprintf(stdout,"\n- Numeros des familles des noeuds : \n"); 677 for (i=0;i<nnoe;i++) 678 fprintf(stdout," %d ",*(nufano+i)); 679 fprintf(stdout,"\n"); 680 } 681 682 683 /* liberation memoire */ 684 free(coo); 685 free(nomnoe); 686 free(numnoe); 687 free(nufano); 688 689 return; 690 } 691 692 693 med_int lecture_nombre_mailles_standards(med_idt fid, 694 char *nommaa, 695 med_geometrie_element typ_geo, 696 med_connectivite typ_con, 697 const int indice) 698 { 699 med_int nmailles = MEDnEntMaa(fid,nommaa,MED_CONN,MED_MAILLE, 700 typ_geo,typ_con); 701 EXIT_IF(nmailles < 0," lors de la lecture du nombre de mailles",NULL); 702 fprintf (stdout,"- Nombre de mailles de type %s : %d \n",nommai[indice], 703 nmailles); 704 705 return nmailles; 706 } 707 708 void lecture_mailles_standards(med_idt fid, 709 char *nommaa, 710 med_int mdim, 711 med_int *nmailles, 712 med_mode_switch mode_coo, 713 med_connectivite typ_con) 714 { 715 med_int taille; 716 med_int *connectivite; 717 char *nomele; 718 med_int *numele; 719 med_int *nufael; 720 med_booleen inoele, inuele; 721 med_geometrie_element typgeo; 722 med_int desmai[MED_NBR_GEOMETRIE_MAILLE] = {0,2,3,3,3,4,4,4,4,6,6,5,5,5,5}; 723 med_int i,j; 724 med_err ret = 0; 725 char str[MED_TAILLE_PNOM+1]; 726 727 fprintf(stdout,"\n(**************************)\n"); 728 fprintf(stdout,"(* ELEMENTS DU MAILLAGE : *)\n"); 729 fprintf(stdout,"(**************************)"); 730 731 /* Lecture des connectivites, noms, numeros des mailles */ 732 for (i=0;i<MED_NBR_GEOMETRIE_MAILLE;i++) 733 if (nmailles[i] > 0) { 734 735 switch(typ_con) { 736 case MED_NOD : 737 taille = typmai[i]%100; 738 break; 739 740 case MED_DESC : 741 taille = desmai[i]; 742 break; 743 744 default : 745 ret = -1; 746 } 747 748 /* allocation memoire */ 749 connectivite = (med_int*) malloc(sizeof(med_int)*taille*nmailles[i]); 750 EXIT_IF(connectivite == NULL,NULL,NULL); 751 nomele = (char*) malloc(sizeof(char)*MED_TAILLE_PNOM*nmailles[i]+1); 752 EXIT_IF(nomele == NULL,NULL,NULL); 753 numele = (med_int*) malloc(sizeof(med_int)*nmailles[i]); 754 EXIT_IF(numele == NULL,NULL,NULL); 755 nufael = (med_int*) malloc(sizeof(med_int)*nmailles[i]); 756 EXIT_IF(nufael == NULL,NULL,NULL); 757 758 /* lecture des données */ 759 ret = MEDelementsLire(fid,nommaa,mdim,connectivite,mode_coo, 760 nomele,&inoele,numele,&inuele,nufael, 761 nmailles[i],MED_MAILLE,typmai[i],typ_con); 762 EXIT_IF(ret < 0,"lors de la lecture des mailles",NULL); 763 764 if (!structure) { 765 /* affichage des resultats */ 766 fprintf(stdout,"\n\n- Mailles de type %s : ", nommai[i]); 767 fprintf(stdout,"\n - Connectivité : \n"); 768 for (j=0;j<nmailles[i]*taille;j++) { 769 if (mode_coo == MED_FULL_INTERLACE && !(j % taille)) 770 fprintf(stdout,"\n [ %5d ] : ", (j/taille +1) ); 771 if (mode_coo == MED_NO_INTERLACE && !(j % nmailles[i])) 772 fprintf(stdout,"\n"); 773 fprintf(stdout," %9d ",*(connectivite+j)); 774 } 775 776 if (inoele) { 777 fprintf(stdout,"\n - Noms : \n"); 778 for (j=0;j<nmailles[i];j++) { 779 strncpy(str,nomele+j*MED_TAILLE_PNOM,MED_TAILLE_PNOM); 780 str[MED_TAILLE_PNOM] = '\0'; 781 fprintf(stdout," %s ",str); 782 } 783 } 784 if (inuele) { 785 fprintf(stdout,"\n - Numeros :\n"); 786 for (j=0;j<nmailles[i];j++) 787 fprintf(stdout," %d ",*(numele+j)); 788 } 789 fprintf(stdout,"\n - Numéros de familles : \n"); 790 for (j=0;j<nmailles[i];j++) 791 fprintf(stdout," %d ",*(nufael+j)); 792 } 793 794 /* liberation memoire */ 795 free(connectivite); 796 free(nomele); 797 free(numele); 798 free(nufael); 799 } 800 801 return; 802 } 803 804 805 med_int lecture_nombre_mailles_polygones(med_idt fid, 806 char *nommaa, 807 med_connectivite typ_con) 808 { 809 med_int nmpolygones = MEDnEntMaa(fid,nommaa,MED_CONN,MED_MAILLE, 810 MED_POLYGONE,typ_con); 811 EXIT_IF(nmpolygones < 0,"lors de la lecture du nombre de mailles polygone\n", 812 NULL); 813 fprintf(stdout,"- Nombre de mailles de type MED_POLYGONE : %d \n", 814 nmpolygones); 815 816 return nmpolygones; 817 } 818 819 void lecture_mailles_polygones(med_idt fid, 820 char *nommaa, 821 med_int nmpolygones, 822 med_mode_switch mode_coo, 823 med_connectivite typ_con) 824 { 825 med_int i,j; 826 med_err ret = 0; 827 med_int taille; 828 med_int *connectivite; 829 char *nomele; 830 med_int *numele; 831 med_int *nufael; 832 med_int *indexp; 833 int ind1,ind2,np; 834 med_int nf; 835 char tmp[MED_TAILLE_NOM+1]; 836 med_err ret1,ret2,ret3; 837 med_int nfa; 838 839 /* lecture des mailles de type MED_POLYGONE */ 840 841 /* quelle taille pour le tableau des connectivites ? */ 842 ret = MEDpolygoneInfo(fid,nommaa,MED_MAILLE,typ_con,&taille); 843 EXIT_IF(ret < 0,"lors de la lecture des parametres des mailles polygones", 844 NULL); 845 846 /* allocation memoire */ 847 indexp = (med_int *) malloc(sizeof(med_int)*(nmpolygones+1)); 848 EXIT_IF(indexp == NULL,NULL,NULL); 849 connectivite = (med_int *) malloc(sizeof(med_int)*taille); 850 EXIT_IF(connectivite == NULL,NULL,NULL); 851 numele = (med_int *) malloc(sizeof(med_int)*nmpolygones); 852 EXIT_IF(numele == NULL,NULL,NULL); 853 nufael = (med_int *) malloc(sizeof(med_int)*nmpolygones); 854 EXIT_IF(nufael == NULL,NULL,NULL); 855 nomele = (char *) malloc(sizeof(char)*MED_TAILLE_PNOM*nmpolygones+1); 856 EXIT_IF(nomele == NULL,NULL,NULL); 857 858 /* lecture de la connectivite des mailles polygones */ 859 ret = MEDpolygoneConnLire(fid,nommaa,indexp,nmpolygones+1,connectivite, 860 MED_MAILLE,typ_con); 861 EXIT_IF(ret < 0,"lors de la lecture des connectivites des mailles polygones", 862 NULL); 863 864 /* lecture noms */ 865 ret1 = MEDnomLire(fid,nommaa,nomele,nmpolygones,MED_MAILLE,MED_POLYGONE); 866 867 /* lecture des numeros */ 868 ret2 = (med_int) MEDnumLire(fid,nommaa,numele,nmpolygones, 869 MED_MAILLE,MED_POLYGONE); 870 871 /* lecture des numeros de familles */ 872 ret3 = MEDfamLire(fid,nommaa,nufael,nmpolygones,MED_MAILLE,MED_POLYGONE); 873 874 if (!structure) { 875 /* affichage des resultats */ 876 fprintf(stdout,"\n\n- Mailles de type MED_POLYGONE : "); 877 for (i=0;i<nmpolygones;i++) { 878 fprintf(stdout,"\n >> Maille MED_POLYGONE %d : \n",i+1); 879 fprintf(stdout,"\n - Connectivité : "); 880 ind1 = *(indexp+i)-1; 881 ind2 = *(indexp+i+1)-1; 882 for (j=ind1;j<ind2;j++) 883 printf(" %d ",*(connectivite+j)); 884 if (ret1 == 0) { 885 strncpy(tmp,nomele+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM); 886 tmp[MED_TAILLE_PNOM] = '\0'; 887 fprintf(stdout,"\n - Nom : %s \n",tmp); 888 } 889 if (ret2 == 0) 890 fprintf(stdout,"\n - Numero : %d \n",*(numele+i)); 891 fprintf(stdout,"\n - Numéro de famille : %d \n",*(nufael+i)); 892 } 893 } 894 895 /* on libere la memoire */ 896 free(indexp); 897 free(connectivite); 898 free(numele); 899 free(nufael); 900 free(nomele); 901 902 return; 903 } 904 905 906 med_int lecture_nombre_mailles_polyedres(med_idt fid, 907 char *nommaa, 908 med_connectivite typ_con) 909 { 910 med_int npolyedres = MEDnEntMaa(fid,nommaa,MED_CONN,MED_MAILLE, 911 MED_POLYEDRE,typ_con); 912 EXIT_IF(npolyedres < 0,"lors de la lecture du nombre de mailles polyedre \n", 913 NULL); 914 fprintf(stdout,"- Nombre de mailles de type MED_POLYEDRE : %d \n", 915 npolyedres); 916 917 return npolyedres; 918 } 919 920 921 void lecture_mailles_polyedres(med_idt fid, 922 char *nommaa, 923 med_int npolyedres, 924 med_mode_switch mode_coo, 925 med_connectivite typ_con) 926 { 927 med_int i,j,k; 928 med_err ret = 0; 929 med_int taille; 930 med_int *connectivite; 931 char *nomele; 932 med_int *numele; 933 med_int *nufael; 934 med_int *indexp, *indexf; 935 int ind1,ind2,np; 936 med_int nf; 937 char tmp[MED_TAILLE_PNOM+1]; 938 med_err ret1,ret2,ret3; 939 med_int nfa; 940 med_int nnoe; 941 942 943 /* lecture des parametres de base */ 944 ret = MEDpolyedreInfo(fid,nommaa,typ_con,&nf,&taille); 945 EXIT_IF(ret < 0,"lors de la lecture des parametres des mailles polyedres0", 946 NULL); 947 948 /* allocation memoire */ 949 indexp = (med_int *) malloc(sizeof(med_int)*(npolyedres+1)); 950 EXIT_IF(indexp == NULL,NULL,NULL); 951 indexf = (med_int *) malloc(sizeof(med_int)*nf); 952 EXIT_IF(indexf == NULL,NULL,NULL); 953 connectivite = (med_int *) malloc(sizeof(med_int)*taille); 954 EXIT_IF(connectivite == NULL,NULL,NULL); 955 numele = (med_int *) malloc(sizeof(med_int)*npolyedres); 956 EXIT_IF(numele == NULL,NULL,NULL); 957 nufael = (med_int *) malloc(sizeof(med_int)*npolyedres); 958 EXIT_IF(nufael == NULL,NULL,NULL); 959 nomele = (char *) malloc(sizeof(char)*MED_TAILLE_PNOM*npolyedres+1); 960 EXIT_IF(nomele == NULL,NULL,NULL); 961 962 /* lecture de la connectivite des mailles polyedres */ 963 ret = MEDpolyedreConnLire(fid,nommaa,indexp,npolyedres+1,indexf,nf, 964 connectivite,typ_con); 965 EXIT_IF(ret < 0, 966 "lors de la lecture de la connectivite des mailles polyedres", 967 NULL); 968 969 /* lecture des noms */ 970 ret1 = MEDnomLire(fid,nommaa,nomele,npolyedres,MED_MAILLE,MED_POLYEDRE); 971 972 /* lecture des numeros */ 973 ret2 = MEDnumLire(fid,nommaa,numele,npolyedres,MED_MAILLE,MED_POLYEDRE); 974 975 /* lecture des numeros de familles */ 976 ret3 = MEDfamLire(fid,nommaa,nufael,npolyedres,MED_MAILLE,MED_POLYEDRE); 977 978 if (!structure) { 979 /* affichage des resultats */ 980 fprintf(stdout,"\n\n- Mailles de type MED_POLYEDRE : "); 981 for (i=0;i<npolyedres;i++) { 982 fprintf(stdout,"\n >> Maille MED_POLYEDRE %d : \n",i+1); 983 fprintf(stdout,"\n - Connectivité : \n"); 984 nfa = *(indexp+i+1) - *(indexp+i); 985 /* ind1 = indice dans "indexf" pour acceder aux numeros des faces */ 986 ind1 = *(indexp+i) - 1; 987 for (j=0;j<nfa;j++) { 988 if (typ_con == MED_NOD) { 989 /* ind2 = indice dans "connectivite" 990 pour acceder au premier noeud de la face */ 991 ind2 = *(indexf+ind1+j) - 1; 992 nnoe = *(indexf+ind1+j+1) - *(indexf+ind1+j); 993 fprintf(stdout," - Face %d : [ ", j+1); 994 for (k=0;k<nnoe;k++) 995 printf(" %d ",*(connectivite+ind2+k)); 996 printf(" ] \n"); 997 } 998 else { 999 nfa = *(indexp+i+1) - *(indexp+i); 1000 /* ind1 = indice dans "connectivite" 1001 pour acceder aux numeros des faces */ 1002 ind1 = *(indexp+i) - 1; 1003 for (j=0;j<nfa;j++) 1004 fprintf(stdout," - Face %d de numero : %d et de type %d \n", j+1, 1005 *(connectivite+ind1+j),*(indexf+ind1+j)); 1006 } 1007 } 1008 if (ret1 == 0) { 1009 strncpy(tmp,nomele+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM); 1010 tmp[MED_TAILLE_PNOM] = '\0'; 1011 fprintf(stdout,"\n - Nom : %s \n",tmp); 1012 } 1013 if (ret2 == 0) 1014 fprintf(stdout,"\n - Numero : %d \n",*(numele+i)); 1015 fprintf(stdout,"\n - Numéro de famille : %d \n",*(nufael+i)); 1016 } 1017 } 1018 1019 /* on libere la memoire */ 1020 free(indexp); 1021 free(indexf); 1022 free(connectivite); 1023 free(numele); 1024 free(nufael); 1025 free(nomele); 1026 1027 return; 1028 } 1029 1030 med_int lecture_nombre_faces_standards(med_idt fid, 1031 char *nommaa, 1032 med_geometrie_element typ_geo, 1033 const med_int indice 1034 ) 1035 { 1036 med_int nfaces = MEDnEntMaa(fid,nommaa,MED_CONN,MED_FACE,typ_geo, 1037 MED_DESC); 1038 EXIT_IF(nfaces < 0,"lors de la lecture du nombre de faces",NULL); 1039 fprintf (stdout,"- Nombre de faces de type %s : %d \n", 1040 nomfac[indice],nfaces); 1041 1042 return nfaces; 1043 } 1044 1045 void lecture_faces_standard(med_idt fid, 1046 char *nommaa, 1047 med_int mdim, 1048 med_int *nfaces, 1049 med_mode_switch mode_coo) 1050 { 1051 med_int taille; 1052 med_int *connectivite; 1053 char *nomele; 1054 med_int *numele; 1055 med_int *nufael; 1056 med_booleen inoele,inuele; 1057 med_geometrie_element typgeo; 1058 med_int i,j; 1059 med_err ret = 0; 1060 char str[MED_TAILLE_PNOM+1]; 1061 med_int desfac[MED_NBR_GEOMETRIE_FACE] = {3,3,4,4}; 1062 1063 for (i=0;i<MED_NBR_GEOMETRIE_FACE;i++) 1064 if (nfaces[i] > 0 ) { 1065 1066 /* taille de la description : nombre d'aretes */ 1067 taille = desfac[i]; 1068 1069 /* allocation memoire */ 1070 connectivite = (med_int*)malloc(sizeof(med_int)*taille*nfaces[i]); 1071 EXIT_IF(connectivite == NULL,NULL,NULL); 1072 nomele = (char*)malloc(sizeof(char)*MED_TAILLE_PNOM*nfaces[i]+1); 1073 EXIT_IF(nomele == NULL,NULL,NULL); 1074 numele = (med_int*)malloc(sizeof(med_int)*nfaces[i]); 1075 EXIT_IF(numele == NULL,NULL,NULL); 1076 nufael = (med_int*)malloc(sizeof(med_int)*nfaces[i]); 1077 EXIT_IF(nufael == NULL,NULL,NULL); 1078 1079 /* lecture des données */ 1080 ret = MEDelementsLire(fid,nommaa,mdim,connectivite,mode_coo, 1081 nomele,&inoele,numele,&inuele,nufael, 1082 nfaces[i],MED_FACE,typfac[i], 1083 MED_DESC); 1084 EXIT_IF(ret < 0,"lors de la lecture des faces",NULL); 1085 1086 if (!structure) { 1087 /* affichage des resultats */ 1088 fprintf(stdout,"\n- Faces de type %s : ", nomfac[i]); 1089 fprintf(stdout,"\n - Connectivité : \n"); 1090 for (j=0;j<nfaces[i]*taille;j++) { 1091 if (mode_coo == MED_FULL_INTERLACE && !(j % taille)) 1092 fprintf(stdout,"\n [ %5d ] : ", (j/taille+1) ); 1093 if (mode_coo == MED_NO_INTERLACE && !(j % nfaces[i])) 1094 fprintf(stdout,"\n"); 1095 fprintf(stdout," %9d ",*(connectivite+j)); 1096 } 1097 1098 if (inoele) { 1099 fprintf(stdout,"\n - Noms : \n"); 1100 for (j=0;j<nfaces[i];j++) { 1101 strncpy(str,nomele+j*MED_TAILLE_PNOM,MED_TAILLE_PNOM); 1102 str[MED_TAILLE_PNOM] = '\0'; 1103 fprintf(stdout," %s ",str); 1104 } 1105 } 1106 if (inuele) { 1107 fprintf(stdout,"\n - Numeros :\n"); 1108 for (j=0;j<nfaces[i];j++) 1109 fprintf(stdout," %d ",*(numele+j)); 1110 } 1111 fprintf(stdout,"\n - Numéros de familles : \n"); 1112 for (j=0;j<nfaces[i];j++) 1113 fprintf(stdout," %d ",*(nufael+j)); 1114 } 1115 1116 /* liberation memoire */ 1117 free(connectivite); 1118 free(nomele); 1119 free(numele); 1120 free(nufael); 1121 } 1122 1123 return; 1124 } 1125 1126 med_int lecture_nombre_faces_polygones(med_idt fid, 1127 char *nommaa) 1128 { 1129 med_int nfpolygones = MEDnEntMaa(fid,nommaa,MED_CONN,MED_FACE,MED_POLYGONE, 1130 MED_DESC); 1131 EXIT_IF(nfpolygones < 0,"lors de la lecture du nombre de faces polygone \n", 1132 NULL); 1133 fprintf(stdout,"- Nombre de faces de type MED_POLYGONE : %d \n", 1134 nfpolygones); 1135 1136 return nfpolygones; 1137 } 1138 1139 void lecture_faces_polygones(med_idt fid, 1140 char *nommaa, 1141 med_int nfpolygones, 1142 med_mode_switch mode_coo) 1143 { 1144 med_int i,j; 1145 med_err ret = 0; 1146 char *nomele; 1147 med_int *numele; 1148 med_int *nufael; 1149 med_int *connectivite; 1150 med_int taille; 1151 med_int *indexp; 1152 int ind1,ind2,np; 1153 med_int nf; 1154 char tmp[MED_TAILLE_NOM+1]; 1155 med_err ret1,ret2,ret3; 1156 med_int nfa; 1157 1158 /* quelle taille pour le tableau des connectivites ? */ 1159 ret = MEDpolygoneInfo(fid,nommaa,MED_FACE,MED_DESC,&taille); 1160 EXIT_IF(ret < 0,"lors de la lecture des parametres des faces polygones", 1161 NULL); 1162 1163 /* allocation memoire */ 1164 indexp = (med_int *) malloc(sizeof(med_int)*(nfpolygones+1)); 1165 EXIT_IF(indexp == NULL,NULL,NULL); 1166 connectivite = (med_int *) malloc(sizeof(med_int)*taille); 1167 EXIT_IF(connectivite == NULL,NULL,NULL); 1168 numele = (med_int *) malloc(sizeof(med_int)*nfpolygones); 1169 EXIT_IF(numele == NULL,NULL,NULL); 1170 nufael = (med_int *) malloc(sizeof(med_int)*nfpolygones); 1171 EXIT_IF(nufael == NULL,NULL,NULL); 1172 nomele = (char *) malloc(sizeof(char)*MED_TAILLE_PNOM*nfpolygones+1); 1173 EXIT_IF(nomele == NULL,NULL,NULL); 1174 1175 /* lecture de la connectivite des faces polygones */ 1176 ret = MEDpolygoneConnLire(fid,nommaa,indexp,nfpolygones+1,connectivite, 1177 MED_FACE,MED_DESC); 1178 EXIT_IF(ret < 0,"lors de la lecture des connectivites des faces polygones", 1179 NULL); 1180 1181 /* lecture des noms */ 1182 ret1 = MEDnomLire(fid,nommaa,nomele,nfpolygones, 1183 MED_FACE,MED_POLYGONE); 1184 1185 /* lecture des numeros */ 1186 ret2 = (med_int) MEDnumLire(fid,nommaa,numele,nfpolygones, 1187 MED_FACE,MED_POLYGONE); 1188 1189 /* lecture des numeros de familles */ 1190 ret3 = MEDfamLire(fid,nommaa,nufael,nfpolygones,MED_FACE,MED_POLYGONE); 1191 1192 if (!structure) { 1193 /* affichage des resultats */ 1194 fprintf(stdout,"\n\n- Faces de type MED_POLYGONE : "); 1195 for (i=0;i<nfpolygones;i++) { 1196 fprintf(stdout,"\n >> Face MED_POLYGONE %d : \n",i+1); 1197 fprintf(stdout,"\n - Connectivité : "); 1198 ind1 = *(indexp+i)-1; 1199 ind2 = *(indexp+i+1)-1; 1200 for (j=ind1;j<ind2;j++) 1201 fprintf(stdout," %d ",*(connectivite+j)); 1202 if (ret1 == 0) { 1203 strncpy(tmp,nomele+j*MED_TAILLE_PNOM,MED_TAILLE_PNOM); 1204 tmp[MED_TAILLE_PNOM] = '\0'; 1205 fprintf(stdout,"\n - Nom : %s \n",tmp); 1206 } 1207 if (ret2 == 0) 1208 fprintf(stdout,"\n - Numero : %d \n",*(numele+j)); 1209 fprintf(stdout,"\n - Numéro de famille : %d \n",*(nufael+j)); 1210 } 1211 } 1212 1213 /* on libere la memoire */ 1214 free(indexp); 1215 free(connectivite); 1216 free(numele); 1217 free(nufael); 1218 free(nomele); 1219 1220 return; 1221 } 1222 1223 1224 med_int lecture_nombre_aretes_standards(med_idt fid, 1225 char *nommaa, 1226 med_geometrie_element typ_geo, 1227 const med_int indice) 1228 { 1229 med_int naretes = MEDnEntMaa(fid,nommaa,MED_CONN,MED_ARETE,typ_geo,MED_DESC); 1230 EXIT_IF(naretes < 0,"lors de la lecture du nombre d'aretes",NULL); 1231 fprintf (stdout, 1232 "- Nombre d'aretes de type %s : %d \n",nomare[indice],naretes); 1233 1234 return naretes; 1235 } 1236 1237 void lecture_aretes_standards(med_idt fid, 1238 char *nommaa, 1239 med_int mdim, 1240 med_int *naretes, 1241 med_mode_switch mode_coo) 1242 { 1243 med_int taille; 1244 med_int *connectivite; 1245 char *nomele; 1246 med_int *numele; 1247 med_int *nufael; 1248 med_booleen inoele,inuele; 1249 med_geometrie_element typgeo; 1250 med_int desare[MED_NBR_GEOMETRIE_ARETE] = {2,3}; 1251 med_int i,j; 1252 med_err ret = 0; 1253 char str[MED_TAILLE_PNOM+1]; 1254 1255 for (i=0;i<MED_NBR_GEOMETRIE_ARETE;i++) 1256 if (naretes[i] > 0) { 1257 1258 taille = desare[i]; 1259 /* dimension de l'arete */ 1260 /* edim = typare[i] / 100; */ 1261 1262 /* allocation memoire */ 1263 connectivite = (med_int*)malloc(sizeof(med_int)*taille*naretes[i]); 1264 EXIT_IF(connectivite == NULL,NULL,NULL); 1265 nomele = (char*)malloc(sizeof(char)*MED_TAILLE_PNOM*naretes[i]+1); 1266 EXIT_IF(nomele == NULL,NULL,NULL); 1267 numele = (med_int*)malloc(sizeof(med_int)*naretes[i]); 1268 EXIT_IF(numele == NULL,NULL,NULL); 1269 nufael = (med_int*)malloc(sizeof(med_int)*naretes[i]); 1270 EXIT_IF(nufael == NULL,NULL,NULL); 1271 1272 /* lecture des données */ 1273 ret = MEDelementsLire(fid,nommaa,mdim,connectivite,mode_coo, 1274 nomele,&inoele,numele,&inuele,nufael, 1275 naretes[i],MED_ARETE,typare[i], 1276 MED_DESC); 1277 EXIT_IF(ret < 0,"lors de la lecture des aretes", 1278 NULL); 1279 1280 if (!structure) { 1281 /* affichage des resultats */ 1282 fprintf(stdout,"\n- Aretes de type %s : ", nomare[i]); 1283 fprintf(stdout,"\n - Connectivité : \n"); 1284 for (j=0;j<naretes[i]*taille;j++) { 1285 if (mode_coo == MED_FULL_INTERLACE && !(j % taille)) 1286 fprintf(stdout,"\n [ %5d ] : ", (j/taille+1) ); 1287 if (mode_coo == MED_NO_INTERLACE && !(j % naretes[i])) 1288 fprintf(stdout,"\n"); 1289 fprintf(stdout," %9d ",*(connectivite+j)); 1290 } 1291 1292 if (inoele) { 1293 fprintf(stdout,"\n - Noms : \n"); 1294 for (j=0;j<naretes[i];j++) { 1295 strncpy(str,nomele+j*MED_TAILLE_PNOM,MED_TAILLE_PNOM); 1296 str[MED_TAILLE_PNOM] = '\0'; 1297 fprintf(stdout," %s ",str); 1298 } 1299 } 1300 if (inuele) { 1301 fprintf(stdout,"\n - Numeros :\n"); 1302 for (j=0;j<naretes[i];j++) 1303 fprintf(stdout," %d ",*(numele+j)); 1304 } 1305 fprintf(stdout,"\n - Numéros de familles : \n"); 1306 for (j=0;j<naretes[i];j++) 1307 fprintf(stdout," %d ",*(nufael+j)); 1308 } 1309 1310 /* liberation memoire */ 1311 free(connectivite); 1312 free(nomele); 1313 free(numele); 1314 free(nufael); 1315 } 1316 1317 return; 1318 } 1319 1320 1321 /****************************************************************************** 1322 * - Nom de la fonction : lecture_maillage_non_structure 1323 * - Description : lecture et affichage d'un maillage MED_NON_STRUCTURE. 1324 * - Parametres : 1325 * - fid (IN) : ID du fichier MED. 1326 * - nommaa (IN) : nom du maillage a lire. 1327 * - mdim (IN) : dimension du maillage. 1328 * - mode_coo (IN) : mode de stockage en memoire : 1329 * MED_FULL_INTERLACE : entrelace | 1330 * MED_NO_INTERLACE : non entrelace. 1331 * - typ_con (IN) : mode de connectivite : 1332 * MED_DESC : descendante | 1333 * MED_NOD : nodale. 1334 * - lecture_en_tete_seulement (IN) : mode de lecture et d'affichage. 1335 ******************************************************************************/ 1336 1337 void lecture_maillage_non_structure(med_idt fid, 1338 char *nommaa, 1339 med_int mdim, 1340 med_mode_switch mode_coo, 1341 med_connectivite typ_con, 1342 const int lecture_en_tete_seulement) 1343 { 1344 med_err ret = 0; 1345 med_int i; 1346 /* nombre d'objets MED : noeuds, mailles, faces, aretes , ... */ 1347 med_int nnoe; 1348 med_int nmailles[MED_NBR_GEOMETRIE_MAILLE]; 1349 med_int nfaces[MED_NBR_GEOMETRIE_FACE]; 1350 med_int naretes[MED_NBR_GEOMETRIE_ARETE]; 1351 /* polygones et polyedres */ 1352 med_int nmpolygones, npolyedres, nfpolygones; 1353 /* familles */ 1354 med_int nfam; 1355 /* equivalences */ 1356 med_int nequ; 1357 /* joints */ 1358 med_int njnt; 1359 1360 /* Combien de noeuds dans le maillage ? */ 1361 nnoe = lecture_nombre_noeuds_maillage_non_structure(fid,nommaa); 1362 1363 /* Combien de mailles, faces ou aretes pour chaque type geometrique ? */ 1364 for (i=0;i<MED_NBR_GEOMETRIE_MAILLE;i++) 1365 nmailles[i] = lecture_nombre_mailles_standards(fid,nommaa,typmai[i], 1366 typ_con,i); 1367 1368 /* Combien de mailles polygones quelconques ? */ 1369 nmpolygones = lecture_nombre_mailles_polygones(fid,nommaa,typ_con); 1370 1371 /* Combien de mailles polyedres quelconques ? */ 1372 npolyedres = lecture_nombre_mailles_polyedres(fid,nommaa,typ_con); 1373 1374 /* Pour la connectivite descendante */ 1375 if (typ_con == MED_DESC) { 1376 1377 /* Combien de faces : types geometriques standards ? */ 1378 for (i=0;i<MED_NBR_GEOMETRIE_FACE;i++) 1379 nfaces[i] = lecture_nombre_faces_standards(fid,nommaa,typfac[i],i); 1380 1381 /* Combien de faces polygones quelconques ? */ 1382 nfpolygones = lecture_nombre_faces_polygones(fid,nommaa); 1383 1384 /* Combien d'aretes */ 1385 for (i=0;i<MED_NBR_GEOMETRIE_ARETE;i++) 1386 naretes[i] = lecture_nombre_aretes_standards(fid,nommaa,typare[i],i); 1387 } 1388 1389 /* combien de familles ? */ 1390 nfam = lecture_nombre_famille(fid,nommaa); 1391 1392 /* combien d'equivalences ? */ 1393 nequ = lecture_nombre_equivalence(fid,nommaa); 1394 1395 /* combien de joints ? */ 1396 njnt = lecture_nombre_joint(fid,nommaa); 1397 1398 /* en fonction du mode de lecture, on continue ou non */ 1399 if (lecture_en_tete_seulement) 1400 return; 1401 1402 /**************************************************************************** 1403 * LECTURE DES NOEUDS * 1404 ****************************************************************************/ 1405 lecture_noeuds_maillage_non_structure(fid,nommaa,mdim,nnoe,mode_coo); 1406 1407 1408 /**************************************************************************** 1409 * LECTURE DES ELEMENTS * 1410 * Mailles : * 1411 * - Types geometriques classiques : MED_SEG2, MED_SEG3, MED_TRIA3, ... * 1412 * - Polygones quelconques. * 1413 * - Polyedres quelconques. * 1414 * Faces (connectivite descendante uniquement) : * 1415 * - Types geometriques classiques. * 1416 * - Polygones quelconques. * 1417 ****************************************************************************/ 1418 1419 /* lecture et affichage des mailles */ 1420 lecture_mailles_standards(fid,nommaa,mdim,nmailles,mode_coo,typ_con); 1421 1422 if (nmpolygones > 0) 1423 lecture_mailles_polygones(fid,nommaa,nmpolygones,mode_coo,typ_con); 1424 1425 if (npolyedres > 0) 1426 lecture_mailles_polyedres(fid,nommaa,npolyedres,mode_coo,typ_con); 1427 1428 /* lecture et affichage des faces en connectivite descendante uniquement */ 1429 if (typ_con == MED_DESC) { 1430 lecture_faces_standard(fid,nommaa,mdim,nfaces,mode_coo); 1431 if (nfpolygones > 0) 1432 lecture_faces_polygones(fid,nommaa,nfpolygones,mode_coo); 1433 } 1434 1435 /* lecture et affichage des aretes en connectivite descendante uniquement */ 1436 if (typ_con == MED_DESC) 1437 lecture_aretes_standards(fid,nommaa,mdim,naretes,mode_coo); 1438 1439 /**************************************************************************** 1440 * LECTURE DES FAMILLES * 1441 ****************************************************************************/ 1442 lecture_famille_maillage(fid,nommaa,nfam); 1443 1444 1445 /**************************************************************************** 1446 * LECTURE DES EQUIVALENCES * 1447 ****************************************************************************/ 1448 lecture_equivalence_maillage(fid,nommaa,nequ); 1449 1450 1451 /**************************************************************************** 1452 * LECTURE DES JOINTS * 1453 ****************************************************************************/ 1454 lecture_joint_maillage(fid,nommaa,njnt); 1455 1456 return; 1457 } 1458 1459 1460 void lecture_caracteristiques_grille(med_idt fid, 1461 char *nommaa, 1462 med_int mdim, 1463 med_int *nind, 1464 med_int *nnoe, 1465 med_int *nmai, 1466 med_type_grille *type) 1467 { 1468 med_err ret = 0; 1469 med_int axe; 1470 med_int *structure_grille; 1471 med_table quoi; 1472 med_int j; 1473 1474 /* lecture de la nature du maillage structure : MED_GRILLE_CARTESIENNE , 1475 ...*/ 1476 ret = MEDnatureGrilleLire(fid,nommaa,type); 1477 EXIT_IF(ret < 0,"a la lecture du type d'une grille ",NULL); 1478 1479 switch(*type) { 1480 1481 case MED_GRILLE_CARTESIENNE : 1482 case MED_GRILLE_POLAIRE : 1483 if (*type == MED_GRILLE_CARTESIENNE) 1484 fprintf(stdout,"- Type de grille : MED_GRILLE_CARTESIENNE \n"); 1485 else 1486 fprintf(stdout,"- Type de grille : MED_GRILLE_POLAIRE \n"); 1487 for (axe=1;axe<=mdim;axe++) { 1488 switch(axe) { 1489 1490 case 1: 1491 quoi = MED_COOR_IND1; 1492 break; 1493 1494 case 2: 1495 quoi = MED_COOR_IND2; 1496 break; 1497 1498 case 3: 1499 quoi = MED_COOR_IND3; 1500 break; 1501 } 1502 nind[axe - 1] = MEDnEntMaa(fid,nommaa,quoi,MED_NOEUD,(med_geometrie_element)0,(med_connectivite)0); 1503 EXIT_IF(nind[axe - 1] < 0, 1504 "lors de la lecture de la taille d'un indice d'une grille", 1505 NULL); 1506 *nnoe = nind[axe - 1] * (*nnoe); 1507 *nmai = (nind[axe - 1] - 1) * (*nmai); 1508 fprintf(stdout, 1509 "- Taille de l'indice de l'axe %d des coordonnees : %d \n", 1510 axe,nind[axe - 1]); 1511 } 1512 break; 1513 1514 case MED_GRILLE_STANDARD: 1515 fprintf(stdout,"- Type de grille : MED_GRILLE_DESTRUCTUREE \n"); 1516 *nnoe = MEDnEntMaa(fid,nommaa,MED_COOR,MED_NOEUD,(med_geometrie_element)0,(med_connectivite)0); 1517 EXIT_IF(*nnoe < 0,"lors de la lecture du nombre de noeuds du maillage " 1518 ,nommaa); 1519 1520 /* on alloue la memoire */ 1521 structure_grille = (med_int *) malloc(sizeof(med_int)*mdim); 1522 EXIT_IF(structure_grille == NULL,NULL,NULL); 1523 /* on lit la structure de la grille 1524 et on affiche le resultat */ 1525 ret = MEDstructureCoordLire(fid,nommaa,mdim,structure_grille); 1526 EXIT_IF(ret < 0,"lors de la lecture de la structure de la grille", 1527 NULL); 1528 fprintf(stdout,"- Structure de la grille : [ "); 1529 for (j=0;j<mdim;j++) { 1530 *nmai = (*(structure_grille+j) - 1) * (*nmai); 1531 fprintf(stdout," %d ",*(structure_grille+j)); 1532 } 1533 fprintf(stdout," ] \n"); 1534 /* on nettoie la memoire */ 1535 free(structure_grille); 1536 break; 1537 } 1538 1539 fprintf(stdout,"- Nombre de noeuds : %d \n",*nnoe); 1540 fprintf(stdout,"- Nombre de mailles : %d \n",*nmai); 1541 1542 return; 1543 } 1544 1545 void lecture_noeuds_maillage_structure(med_idt fid, char *nommaa, 1546 med_int mdim,med_int *nind,med_int nnoe, 1547 med_type_grille type, 1548 const med_mode_switch mode_coo) 1549 { 1550 med_err ret = 0; 1551 med_int axe,i,j; 1552 char comp_ind[MED_TAILLE_PNOM+1]; 1553 char unit_ind[MED_TAILLE_PNOM+1]; 1554 char comp[3*MED_TAILLE_PNOM+1]; 1555 char unit[3*MED_TAILLE_PNOM+1]; 1556 char str[MED_TAILLE_PNOM+1]; 1557 med_float *coo = NULL; 1558 med_float *indices = NULL; 1559 med_table quoi; 1560 med_repere repere; 1561 med_int *nufano = NULL; 1562 med_int *numnoe = NULL; 1563 char *nomnoe = NULL; 1564 1565 fprintf(stdout,"\n(*************************)\n"); 1566 fprintf(stdout,"(* NOEUDS DE LA GRILLE : *)\n"); 1567 fprintf(stdout,"(*************************)\n"); 1568 1569 switch(type) { 1570 1571 case MED_GRILLE_CARTESIENNE : 1572 case MED_GRILLE_POLAIRE : 1573 /* on affiche les coordonnees de chacun des axes */ 1574 for (axe = 1; axe<=mdim; axe++) { 1575 /* on alloue la memoire */ 1576 indices = (med_float *) malloc(sizeof(med_float)*nind[axe - 1]); 1577 EXIT_IF(indices == NULL,NULL,NULL); 1578 /* on lit le tableau des indices de coordonnees 1579 et on affiche le resultat */ 1580 ret = MEDindicesCoordLire(fid,nommaa,mdim,indices,nind[axe - 1], 1581 axe,comp_ind,unit_ind); 1582 EXIT_IF(ret < 0,"lors de la lecture d'un tableau d'indice", 1583 NULL); 1584 fprintf(stdout,"\n - Axe %s [%s] : [ ",comp_ind,unit_ind); 1585 for (j=0;j<nind[axe - 1];j++) 1586 fprintf(stdout," %f ",*(indices+j)); 1587 printf(" ] \n"); 1588 /* on nettoie la memoire */ 1589 free(indices); 1590 } 1591 break; 1592 1593 case MED_GRILLE_STANDARD: 1594 /* on alloue la memoire */ 1595 coo = (med_float *) malloc(sizeof(med_float)*nnoe*mdim); 1596 EXIT_IF(coo == NULL,NULL,NULL); 1597 /* on va lire les coordonnees des noeuds */ 1598 ret = MEDcoordLire(fid,nommaa,mdim,coo,MED_FULL_INTERLACE,MED_ALL,NULL,0, 1599 &repere,comp,unit); 1600 EXIT_IF(ret < 0,"lors de la lecture des noeuds du maillage",NULL); 1601 /* on affiche le resultat */ 1602 fprintf(stdout,"- Nom des coordonnees : \n"); 1603 for (i=0;i<mdim;i++) { 1604 strncpy(str,comp+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM); 1605 str[MED_TAILLE_PNOM] = '\0'; 1606 fprintf(stdout," %s ",str); 1607 } 1608 fprintf(stdout,"\n- Unites des coordonnees : \n"); 1609 for (i=0;i<mdim;i++) { 1610 strncpy(str,unit+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM); 1611 str[MED_TAILLE_PNOM] = '\0'; 1612 fprintf(stdout," %s ",str); 1613 } 1614 if (!structure) { 1615 fprintf(stdout,"\n - Coordonnees des noeuds : [ "); 1616 for (j=0;j<nnoe*mdim;j++) 1617 fprintf(stdout," %f ",*(coo+j)); 1618 fprintf(stdout," ] \n"); 1619 } 1620 1621 /* on nettoie la memoire */ 1622 free(coo); 1623 break; 1624 } 1625 1626 /* lecture et affichage des : 1627 - numeros de familles des noeuds 1628 - noms des noeuds (optionnel) 1629 - numeros des noeuds (optionnel) */ 1630 1631 /* on alloue la memoire */ 1632 numnoe = (med_int *) malloc(sizeof(med_int)*nnoe); 1633 EXIT_IF(numnoe == NULL,NULL,NULL); 1634 nomnoe = (char*) malloc(MED_TAILLE_PNOM*nnoe+1); 1635 EXIT_IF(nomnoe == NULL,NULL,NULL); 1636 nufano = (med_int *) malloc(sizeof(med_int)*nnoe); 1637 EXIT_IF(nufano == NULL,NULL,NULL); 1638 1639 /* on va lire les numeros de familles des noeuds */ 1640 ret = MEDfamLire(fid,nommaa,nufano,nnoe,MED_NOEUD,(med_geometrie_element)0); 1641 EXIT_IF(ret < 0,"lors de la lecture des numeros de familles des noeuds", 1642 NULL); 1643 if (!structure) { 1644 /* on affiche le resultat */ 1645 fprintf(stdout,"\n- Numeros des familles des noeuds : \n"); 1646 for (i=0;i<nnoe;i++) 1647 fprintf(stdout," %d ",*(nufano+i)); 1648 fprintf(stdout,"\n"); 1649 } 1650 1651 /* on va lire et afficher les noms des noeuds */ 1652 if (MEDnomLire(fid,nommaa,nomnoe,nnoe,MED_NOEUD,MED_POINT1) == 0) { 1653 if (!structure) { 1654 fprintf(stdout,"\n- Noms des noeuds : \n"); 1655 for (i=0;i<nnoe;i++) { 1656 strncpy(str,nomnoe+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM); 1657 str[MED_TAILLE_PNOM] = '\0'; 1658 fprintf(stdout," %s ",str); 1659 } 1660 } 1661 } 1662 1663 /* on va lire et afficher les numeros des noeuds */ 1664 if (MEDnumLire(fid,nommaa,numnoe,nnoe,MED_NOEUD,MED_POINT1) == 0) { 1665 if (!structure) { 1666 fprintf(stdout,"\n- Numeros des noeuds : \n"); 1667 for (i=0;i<nnoe;i++) 1668 fprintf(stdout," %d ",*(numnoe+i)); 1669 } 1670 } 1671 1672 /* on nettoie la memoire */ 1673 free(nufano); 1674 free(numnoe); 1675 free(nomnoe); 1676 1677 return; 1678 } 1679 1680 1681 void lecture_mailles_maillage_structure(med_idt fid, char *nommaa, 1682 const med_int mdim,const med_int nmai) 1683 { 1684 med_err ret = 0; 1685 med_int i; 1686 med_int *nufael = NULL; 1687 char *nomele = NULL; 1688 med_int *numele = NULL; 1689 char str[MED_TAILLE_PNOM+1]; 1690 /* type geometrique des elements */ 1691 med_geometrie_element typgeo; 1692 1693 fprintf(stdout,"\n(***************************)\n"); 1694 fprintf(stdout,"(* ELEMENTS DE LA GRILLE : *)\n"); 1695 fprintf(stdout,"(***************************)\n"); 1696 1697 /* type des mailles */ 1698 switch(mdim) { 1699 case 0 : 1700 typgeo = MED_POINT1; 1701 break; 1702 case 1 : 1703 typgeo = MED_SEG2; 1704 break; 1705 case 2 : 1706 typgeo = MED_QUAD4; 1707 break; 1708 default : 1709 typgeo = MED_HEXA8; 1710 } 1711 1712 /* On va lire et afficher : 1713 * - Les numeros de familles 1714 * - Les noms (optionnel) 1715 * - Les numeros (optionnel) 1716 */ 1717 1718 /* on alloue la memoire */ 1719 numele = (med_int *) malloc(sizeof(med_int)*nmai); 1720 EXIT_IF(numele == NULL,NULL,NULL); 1721 nomele = (char *) malloc(sizeof(char)*MED_TAILLE_PNOM*nmai+1); 1722 EXIT_IF(nomele == NULL,NULL,NULL); 1723 nufael = (med_int *) malloc(sizeof(med_int)*nmai); 1724 EXIT_IF(nufael == NULL,NULL,NULL); 1725 1726 /* lecture des numeros de famille */ 1727 ret = MEDfamLire(fid,nommaa,nufael,nmai,MED_MAILLE,typgeo); 1728 if (ret < 0) 1729 for (i=0;i<nmai;i++) 1730 *(nufael+i) = 0; 1731 1732 if (!structure) { 1733 /* on affiche le resultat */ 1734 fprintf(stdout,"\n- Numeros des familles des mailles : \n"); 1735 for (i=0;i<nmai;i++) 1736 fprintf(stdout," %d ",*(nufael+i)); 1737 fprintf(stdout,"\n"); 1738 } 1739 1740 /* on va lire et afficher les noms des mailles */ 1741 if (MEDnomLire(fid,nommaa,nomele,nmai,MED_MAILLE,typgeo) == 0) { 1742 if (!structure) { 1743 fprintf(stdout,"\n - Noms : \n"); 1744 for (i=0;i<nmai;i++) { 1745 strncpy(str,nomele+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM); 1746 str[MED_TAILLE_PNOM] = '\0'; 1747 fprintf(stdout," %s ",str); 1748 } 1749 } 1750 } 1751 1752 /* on va lire et afficher les numeros des mailles */ 1753 if (MEDnumLire(fid,nommaa,numele,nmai,MED_MAILLE,typgeo) == 0) { 1754 if (!structure) { 1755 fprintf(stdout,"\n - Numeros :\n"); 1756 for (i=0;i<nmai;i++) 1757 fprintf(stdout," %d ",*(numele+i)); 1758 } 1759 } 1760 1761 /* on libere la memoire */ 1762 free(nufael); 1763 free(nomele); 1764 free(numele); 1765 1766 return; 1767 } 1768 1769 1770 void lecture_maillage_structure(med_idt fid, char *nommaa,med_int mdim, 1771 const med_mode_switch mode_coo, 1772 const int lecture_en_tete_seulement) 1773 { 1774 med_err ret = 0; 1775 /* nombre de valeurs selon les axes du repere */ 1776 med_int nind[3]; 1777 med_int nnoe = 1; 1778 med_int nmai = 1; 1779 /* type de la grille */ 1780 med_type_grille type; 1781 /* nombre de familles */ 1782 med_int nfam; 1783 /* nombre d'equivalences */ 1784 med_int nequ; 1785 /* nombre de joints */ 1786 med_int njnt; 1787 1788 /* lecture selon la nature de la grille des caracteristiques 1789 du maillage : 1790 - nombre de noeuds 1791 - nombre de mailles 1792 */ 1793 lecture_caracteristiques_grille(fid,nommaa,mdim,nind,&nnoe,&nmai,&type); 1794 1795 /* nombre de familles */ 1796 nfam = lecture_nombre_famille(fid,nommaa); 1797 1798 /* nombre d'equivalences */ 1799 nequ = lecture_nombre_equivalence(fid,nommaa); 1800 1801 /* combien de joints */ 1802 njnt = lecture_nombre_joint(fid,nommaa); 1803 1804 if (lecture_en_tete_seulement) 1805 return ; 1806 1807 /**************************************************************************** 1808 * LECTURE DES NOEUDS * 1809 ****************************************************************************/ 1810 lecture_noeuds_maillage_structure(fid,nommaa,mdim,nind,nnoe,type,mode_coo); 1811 1812 /**************************************************************************** 1813 * LECTURE DES ELEMENTS * 1814 ****************************************************************************/ 1815 lecture_mailles_maillage_structure(fid,nommaa,mdim,nmai); 1816 1817 /**************************************************************************** 1818 * LECTURE DES FAMILLES * 1819 ****************************************************************************/ 1820 lecture_famille_maillage(fid,nommaa,nfam); 1821 1822 /**************************************************************************** 1823 * LECTURE DES EQUIVALENCES * 1824 ****************************************************************************/ 1825 lecture_equivalence_maillage(fid,nommaa,nequ); 1826 1827 /**************************************************************************** 1828 * LECTURE DES JOINTS * 1829 ****************************************************************************/ 1830 lecture_joint_maillage(fid,nommaa,njnt); 1831 1832 return ; 1833 } 1834 1835 1836 1837 med_err getFieldsOn(med_idt fid, char* maillage, 1838 char * nomcha, med_type_champ typcha, med_int ncomp, 1839 med_entite_maillage entite, med_mode_switch stockage) { 1840 1841 int j,k,l,m,n,nb_geo; 1842 med_int nbpdtnor=0,pflsize,*pflval,ngauss=0,ngroup,*vale=NULL,nval; 1843 med_int numdt=0,numo=0,lnsize,nbrefmaa; 1844 med_float *valr=NULL,dt=0.0; 1845 med_err ret=0; 1846 med_booleen local; 1847 char pflname [MED_TAILLE_NOM+1]=""; 1848 char locname [MED_TAILLE_NOM+1]=""; 1849 char * lien = NULL; 1850 char maa_ass [MED_TAILLE_NOM+1]=""; 1851 char dt_unit [MED_TAILLE_PNOM+1]=""; 1852 med_geometrie_element * type_geo; 1853 med_geometrie_element typ_noeud[1] = { MED_NONE }; 1854 med_geometrie_element typmai[MED_NBR_GEOMETRIE_MAILLE+2] = {MED_POINT1, 1855 MED_SEG2, 1856 MED_SEG3, 1857 MED_TRIA3, 1858 MED_QUAD4, 1859 MED_TRIA6, 1860 MED_QUAD8, 1861 MED_TETRA4, 1862 MED_PYRA5, 1863 MED_PENTA6, 1864 MED_HEXA8, 1865 MED_TETRA10, 1866 MED_PYRA13, 1867 MED_PENTA15, 1868 MED_HEXA20, 1869 MED_POLYGONE, 1870 MED_POLYEDRE}; 1871 med_geometrie_element typfac[MED_NBR_GEOMETRIE_FACE+1] = {MED_TRIA3, 1872 MED_TRIA6, 1873 MED_QUAD4, 1874 MED_QUAD8, 1875 MED_POLYGONE}; 1876 med_geometrie_element typare[MED_NBR_GEOMETRIE_ARETE] = {MED_SEG2,MED_SEG3}; 1877 1878 char ** AFF; 1879 1880 switch (entite) { 1881 case MED_NOEUD : 1882 type_geo = typ_noeud; 1883 nb_geo = 1; 1884 AFF = MED_GEOMETRIE_NOEUD_AFF; 1885 break; 1886 case MED_MAILLE : 1887 case MED_NOEUD_MAILLE : 1888 type_geo = typmai; 1889 nb_geo = MED_NBR_GEOMETRIE_MAILLE+2; 1890 AFF = MED_GEOMETRIE_MAILLE_AFF; 1891 break; 1892 case MED_FACE : 1893 type_geo = typfac; 1894 nb_geo = MED_NBR_GEOMETRIE_FACE+1; 1895 AFF = MED_GEOMETRIE_FACE_AFF; 1896 break; 1897 case MED_ARETE : 1898 type_geo = typare; 1899 nb_geo = MED_NBR_GEOMETRIE_ARETE; 1900 AFF = MED_GEOMETRIE_ARETE_AFF; 1901 break; 1902 } 1903 1904 for (k=0;k<nb_geo;k++) { 1905 1906 /* Combien de (PDT,NOR) a lire */ 1907 nbpdtnor = MEDnPasdetemps(fid,nomcha,entite,type_geo[k]); 1908 if (nbpdtnor < 1 ) continue; 1909 1910 for (j=0;j<nbpdtnor;j++) { 1911 1912 if ( MEDpasdetempsInfo(fid,nomcha,entite,type_geo[k], 1913 j+1, &ngauss, &numdt, &numo, dt_unit, 1914 &dt, maa_ass, &local, &nbrefmaa) <0) { 1915 MESSAGE("Erreur a la demande d'information sur (pdt,nor) : "); 1916 ISCRUTE(numdt); ISCRUTE(numo); 1917 ret = -1; continue; 1918 }; 1919 1920 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); 1921 1922 printf("\tLe maillage par defaut est : |%s|, sur un total de : %i maillages associes\n", 1923 maa_ass, nbrefmaa); 1924 1925 /* Le maillage reference est-il porte par un autre fichier */ 1926 if ( !local ) { 1927 1928 if ( (lnsize=MEDnValLien(fid,maa_ass) ) < 0 ) { 1929 MESSAGE("Erreur a la lecture de la taille du lien : "); 1930 SSCRUTE(maa_ass); 1931 ret = -1; 1932 } else { 1933 1934 lien = (char *)malloc(lnsize*sizeof(char) + 1); 1935 EXIT_IF(lien == NULL,NULL,NULL); 1936 1937 if ( MEDlienLire(fid, lien, maa_ass) < 0 ) { 1938 MESSAGE("Erreur a la lecture du lien : "); 1939 SSCRUTE(maa_ass);SSCRUTE(lien); 1940 ret = -1; 1941 } else { 1942 lien[lnsize] = '\0'; 1943 printf("\tLe maillage |%s| est porte par un fichier distant |%s|\n" 1944 ,maa_ass,lien); 1945 } 1946 free(lien); 1947 } 1948 } 1949 1950 /* Combien de maillages lies aux (nomcha,ent,geo,numdt,numo) */ 1951 /* Notons que cette information est egalement disponible a partir de MEDpasdetempsInfo */ 1952 if ( (nbrefmaa = MEDnChampRef(fid,nomcha,entite,type_geo[k],numdt,numo) ) < 0 ) { 1953 MESSAGE("Erreur a la demande du nombre de maillages references par le champ : "); 1954 SSCRUTE(nomcha); ISCRUTE(numdt); ISCRUTE(numo); 1955 ret = -1; continue; 1956 }; 1957 1958 for (l=0;l<nbrefmaa;l++) { 1959 1960 if ( MEDchampRefInfo(fid,nomcha,entite,type_geo[k], 1961 l+1,numdt, numo, maa_ass, &local, &ngauss) <0 ) { 1962 MESSAGE("Erreur a la demande d'information sur le maillage utilise par le champ n° : "); 1963 ISCRUTE(l+1); 1964 ret = -1; continue; 1965 }; 1966 1967 /* Prend en compte le nbre de pt de gauss automatiquement */ 1968 if ((nval = MEDnVal(fid,nomcha,entite,type_geo[k],numdt,numo,maa_ass,USER_MODE)) <= 0) { 1969 MESSAGE("Erreur a la lecture du nombre de valeurs du champ : "); 1970 SSCRUTE(nomcha);ISCRUTE(entite);ISCRUTE(type_geo[k]); 1971 ISCRUTE(numdt);ISCRUTE(numo);SSCRUTE(maa_ass);ISCRUTE(USER_MODE); 1972 ret = -1; continue; 1973 }; 1974 1975 if (! strcmp(maa_ass,maillage)) { 1976 printf("\t- Il y a %d valeurs en mode %i. Chaque entite %s\ 1977 de type geometrique %s associes au maillage |%s| a %i pts de gauss \n", 1978 nval,USER_MODE,MED_ENTITE_MAILLAGE_AFF[(int)entite],AFF[k], 1979 maa_ass,ngauss); 1980 1981 /* Le maillage reference est-il porte par un autre fichier */ 1982 if ( !local ) { 1983 1984 if ( (lnsize=MEDnValLien(fid,maa_ass) ) < 0 ) { 1985 MESSAGE("Erreur a la lecture de la taille du lien : "); 1986 SSCRUTE(maa_ass); 1987 ret = -1; 1988 } else { 1989 lien = (char *)malloc(lnsize*sizeof(char) + 1); 1990 EXIT_IF(lien == NULL,NULL,NULL); 1991 1992 if ( MEDlienLire(fid, lien, maa_ass) < 0 ) { 1993 MESSAGE("Erreur a la lecture du lien : "); 1994 SSCRUTE(maa_ass);SSCRUTE(lien); 1995 ret = -1; 1996 } else { 1997 lien[lnsize] = '\0'; 1998 printf("\tLe maillage |%s| est porte par un fichier distant |%s|\n",maa_ass,lien); 1999 } 2000 free(lien); 2001 } 2002 } 2003 2004 /*Lecture des valeurs du champ */ 2005 if (typcha == MED_FLOAT64) { 2006 2007 valr = (med_float*) calloc(ncomp*nval,sizeof(med_float)); 2008 EXIT_IF(valr == NULL,NULL,NULL); 2009 if ( MEDchampLire(fid,maa_ass,nomcha,(unsigned char*)valr,stockage, 2010 MED_ALL,locname, 2011 pflname,USER_MODE,entite, 2012 type_geo[k],numdt,numo) < 0 ) { 2013 MESSAGE("Erreur a la lecture du nombre de valeurs du champ : "); 2014 SSCRUTE(nomcha);ISCRUTE(entite);ISCRUTE(type_geo[k]); 2015 ISCRUTE(numdt);ISCRUTE(numo);SSCRUTE(maa_ass); 2016 ret = -1; 2017 }; 2018 2019 } else { 2020 2021 vale = (med_int*) calloc(ncomp*nval,sizeof(med_int)); 2022 EXIT_IF(vale == NULL,NULL,NULL); 2023 if ( MEDchampLire(fid,maa_ass,nomcha,(unsigned char*)vale,stockage,MED_ALL,locname, 2024 pflname,USER_MODE,entite,type_geo[k],numdt,numo) < 0 ) { 2025 MESSAGE("Erreur a la lecture des valeurs du champ : "); 2026 SSCRUTE(nomcha);ISCRUTE(entite);ISCRUTE(type_geo[k]); 2027 ISCRUTE(numdt);ISCRUTE(numo);SSCRUTE(maa_ass); 2028 ret = -1; 2029 }; 2030 2031 } 2032 2033 if (entite == MED_NOEUD_MAILLE ) 2034 ngroup = type_geo[k] % 100; 2035 else 2036 ngroup = ngauss; 2037 2038 switch (stockage) { 2039 2040 case MED_FULL_INTERLACE : 2041 if (!structure) { 2042 printf("\t- Valeurs :\n\t"); 2043 for (m=0;m<nval/ngroup;m++) { 2044 printf("|"); 2045 for (n=0;n<ngroup*ncomp;n++) 2046 if (typcha == MED_FLOAT64) 2047 printf(" %f ",*(valr+(m*ngroup*ncomp)+n)); 2048 else 2049 printf(" %d ",*(vale+(m*ngroup*ncomp)+n)); 2050 2051 } 2052 } 2053 break; 2054 2055 case MED_NO_INTERLACE : 2056 if (!structure) { 2057 printf("\t- Valeurs :\n\t"); 2058 for (m=0;m<ncomp;m++) { 2059 printf("|"); 2060 for (n=0;n<nval;n++) 2061 if (typcha == MED_FLOAT64) 2062 printf(" %f ",*(valr+(m*nval)+n)); 2063 else 2064 printf(" %d ",*(vale+(m*nval)+n)); 2065 } 2066 } 2067 break; 2068 } 2069 2070 if (!structure) { 2071 printf("|\n"); 2072 } 2073 if (typcha == MED_FLOAT64) { 2074 if ( valr ) {free(valr);valr = NULL;}} 2075 else 2076 if (vale) { free(vale);vale = NULL; } 2077 2078 /*Lecture du profil associe */ 2079 if (strcmp(pflname,MED_NOPFL) == 0 ) 2080 printf("\t- Profil : MED_NOPFL\n"); 2081 else { 2082 2083 if ( (pflsize = MEDnValProfil(fid,pflname)) <0 ) { 2084 MESSAGE("Erreur a la lecture du nombre de valeurs du profil : "); 2085 SSCRUTE(pflname); 2086 ret = -1; continue; 2087 } 2088 2089 printf("\t- Profil : |%s| de taille %i\n",pflname,pflsize); 2090 2091 pflval = (med_int*) malloc(sizeof(med_int)*pflsize); 2092 EXIT_IF(pflval == NULL,NULL,NULL); 2093 if ( MEDprofilLire(fid,pflval,pflname) <0) { 2094 MESSAGE("Erreur a la lecture des valeurs du profil : "); 2095 SSCRUTE(pflname); 2096 ret = -1; 2097 } 2098 if (!structure) { 2099 printf("\t"); 2100 for (m=0;m<pflsize;m++) printf(" %i ",*(pflval+m)); 2101 printf("\n"); 2102 } 2103 free(pflval); 2104 2105 } 2106 } 2107 2108 } 2109 } 2110 } /* fin for sur les mailles*/ 2111 2112 return ret; 2113 } 2114 2115 /****************************************************************************** 2116 * 2117 * - Nom de la fonction : lecture_resultats 2118 * - Description : lecture et affichage des champs de resultats 2119 * associe a un maillage MED. 2120 * - Parametres : 2121 * - fid (IN) : ID du fichier MED. 2122 * - maillage (IN) : nom du maillage maillage. 2123 * - mode_coo (IN) : mode de stockage en memoire : 2124 * MED_FULL_INTERLACE | 2125 * MED_NO_INTERLACE. 2126 * - lecture_en_tete_seulement (IN) : mode de lecture. 2127 ******************************************************************************/ 2128 2129 void lecture_resultats(med_idt fid, 2130 char * maillage, 2131 med_mode_switch mode_coo, 2132 int lecture_en_tete_seulement) 2133 { 2134 med_err ret,lret; 2135 char pflname[MED_TAILLE_NOM+1]="",nomlien[MED_TAILLE_NOM+1]=""; 2136 char * lien = NULL; 2137 char *comp, *unit; 2138 char nomcha [MED_TAILLE_NOM+1]=""; 2139 char locname[MED_TAILLE_NOM+1]=""; 2140 med_int mdim,ncomp,ncha,npro,nln,pflsize,*pflval,nval,nloc,ngauss; 2141 med_type_champ typcha; 2142 med_maillage type; 2143 int t1,t2,t3; 2144 med_geometrie_element type_geo; 2145 med_float *refcoo, *gscoo, *wg; 2146 int i,j; 2147 2148 if (! lecture_en_tete_seulement) { 2149 fprintf(stdout,"\n(************************)\n"); 2150 fprintf(stdout,"(* CHAMPS DU MAILLAGE : *)\n"); 2151 fprintf(stdout,"(************************)\n"); 2152 } 2153 2154 /* combien de champs dans le fichier */ 2155 ncha = MEDnChamp(fid,0); 2156 EXIT_IF(ncha < 0,"lors de la lecture du nombre de champs",NULL); 2157 fprintf(stdout,"- Nombre de champs : %d \n",ncha); 2158 2159 if (lecture_en_tete_seulement) 2160 return; 2161 2162 /**************************************************************************** 2163 * LECTURE DES CHAMPS * 2164 ****************************************************************************/ 2165 ret = 0; 2166 2167 /* lecture de tous les champs pour le maillage selectionne */ 2168 for (i =0;i<ncha;i++) { 2169 lret = 0; 2170 printf("\nChamp numero : |%d| \n",i+1); 2171 2172 /* Lecture du nombre de composantes */ 2173 if ((ncomp = MEDnChamp(fid,i+1)) < 0) { 2174 MESSAGE("Erreur à la lecture du nombre de composantes : "); 2175 ISCRUTE(ncomp); 2176 ret = -1; continue; 2177 } 2178 2179 /* Lecture du type du champ, des noms des composantes et du nom de 2180 l'unité*/ 2181 comp = (char*) malloc(ncomp*MED_TAILLE_PNOM+1); 2182 EXIT_IF(comp == NULL,NULL,NULL); 2183 unit = (char*) malloc(ncomp*MED_TAILLE_PNOM+1); 2184 EXIT_IF(unit == NULL,NULL,NULL); 2185 2186 if ( MEDchampInfo(fid,i+1,nomcha,&typcha,comp,unit,ncomp) < 0 ) { 2187 MESSAGE("Erreur à la demande d'information sur les champs : "); 2188 ret = -1; continue; 2189 } 2190 2191 printf("Nom du champ : |%s| de type |%d|\n",nomcha,typcha); 2192 printf("Nom des composantes : |%s|\n",comp); 2193 printf("Unites des composantes : |%s| \n",unit); 2194 2195 free(comp); 2196 free(unit); 2197 2198 /* champs aux noeuds */ 2199 lret = getFieldsOn(fid, maillage, nomcha, typcha, ncomp, MED_NOEUD,mode_coo); 2200 2201 /* champs sur les elements et aux points de Gauss */ 2202 if (lret == 0) lret = getFieldsOn(fid, maillage, nomcha, typcha, ncomp, MED_MAILLE,mode_coo); 2203 else { MESSAGE("Erreur à la lecture des champs aux noeuds "); ret = -1; continue;} 2204 2205 if (lret == 0) lret = getFieldsOn(fid, maillage, nomcha, typcha, ncomp, MED_FACE,mode_coo); 2206 else { MESSAGE("Erreur à la lecture des champs aux mailles "); ret = -1; continue;} 2207 2208 if (lret == 0) lret = getFieldsOn(fid, maillage, nomcha, typcha, ncomp, MED_ARETE,mode_coo); 2209 else {MESSAGE("Erreur à la lecture des champs aux faces "); ret = -1; continue;} 2210 2211 if (lret == 0) lret = getFieldsOn(fid, maillage, nomcha, typcha, ncomp, MED_NOEUD_MAILLE,mode_coo); 2212 else {MESSAGE("Erreur a la lecture des champs aux aretes "); ret = -1; continue;} 2213 2214 if (lret != 0) {MESSAGE("Erreur a la lecture des champs aux noeuds des mailles "); ret = -1;}; 2215 } 2216 2217 2218 /* Interrogation des profils */ 2219 npro = MEDnProfil(fid); 2220 2221 printf("\nNombre de profils stockes : %i\n\n",npro); 2222 for (i=1 ; i <= npro ; i++ ) { 2223 if ( MEDprofilInfo(fid, i, pflname, &nval) < 0) { 2224 MESSAGE("Erreur a la demande d'information sur le profil n° : "); ISCRUTE(i); 2225 ret = -1;continue; 2226 } 2227 printf("\t- Profil n°%i de nom |%s| et de taille %i\n",i,pflname,nval); 2228 pflval = (med_int*) malloc(sizeof(med_int)*nval); 2229 if ( MEDprofilLire(fid, pflval, pflname) < 0) { 2230 MESSAGE("Erreur a la lecture des valeurs du profil : "); 2231 SSCRUTE(pflname); 2232 ret = -1; 2233 } else { 2234 if (!structure) { 2235 printf("\t"); 2236 for (j=0;j<nval;j++) printf(" %i ",*(pflval+j)); 2237 printf("\n\n"); 2238 } 2239 } 2240 free(pflval); 2241 } 2242 2243 /* Interrogation des liens */ 2244 nln = MEDnLien(fid); 2245 2246 printf("\nNombre de liens stockes : %i\n\n",nln); 2247 for (i=1 ; i <= nln ; i++ ) { 2248 if ( MEDlienInfo(fid, i, nomlien, &nval) < 0) { 2249 MESSAGE("Erreur a la demande d'information sur le lien n° : "); ISCRUTE(i); 2250 ret = -1;continue; 2251 } 2252 printf("\t- Lien n°%i de nom |%s| et de taille %i\n",i,nomlien,nval); 2253 2254 lien = (char *)malloc(nval*sizeof(char) + 1); 2255 EXIT_IF(lien == NULL,NULL,NULL); 2256 2257 if ( MEDlienLire(fid, lien, nomlien) < 0 ) { 2258 MESSAGE("Erreur a la lecture du lien : "); 2259 SSCRUTE(nomlien);SSCRUTE(lien); 2260 ret = -1; 2261 } else { 2262 lien[nval] = '\0'; 2263 printf("\t\t|%s|\n\n",lien); 2264 } 2265 free(lien); 2266 } 2267 2268 /* Interrogation des localisations des points de GAUSS */ 2269 nloc = MEDnGauss(fid); 2270 2271 printf("\nNombre de localisations stockees : %i\n\n",nloc); 2272 for (i=1 ; i <= nloc ; i++ ) { 2273 if ( MEDgaussInfo(fid, i, locname, &type_geo, &ngauss) < 0) { 2274 MESSAGE("Erreur a la demande d'information sur la localisation n° : "); ISCRUTE(i); 2275 ret = -1;continue; 2276 } 2277 printf("\t- Loc. n°%i de nom |%s| et nbr. de pts de GAUSS %i\n",i,locname,ngauss); 2278 t1 = (type_geo%100)*(type_geo/100); 2279 t2 = ngauss*(type_geo/100); 2280 t3 = ngauss; 2281 refcoo = (med_float *) malloc(sizeof(med_float)*t1 ); 2282 gscoo = (med_float *) malloc(sizeof(med_float)*t2 ); 2283 wg = (med_float *) malloc(sizeof(med_float)*t3 ); 2284 2285 if ( MEDgaussLire(fid, refcoo, gscoo, wg, mode_coo, locname ) < 0) { 2286 MESSAGE("Erreur a la lecture des valeurs de la localisation : "); 2287 SSCRUTE(locname); 2288 ret = -1; 2289 } else { 2290 if (!structure) { 2291 printf("\t Coordonnees de l'element de reference de type %i :\n\t\t",type_geo); 2292 for (j=0;j<t1;j++) printf(" %f ",*(refcoo+j)); 2293 printf("\n"); 2294 printf("\t Localisation des points de GAUSS : \n\t\t"); 2295 for (j=0;j<t2;j++) printf(" %f ",*(gscoo+j)); 2296 printf("\n"); 2297 printf("\t Poids associes aux points de GAUSS :\n\t\t"); 2298 for (j=0;j<t3;j++) printf(" %f ",*(wg+j)); 2299 printf("\n\n"); 2300 } 2301 } 2302 free(refcoo); 2303 free(gscoo); 2304 free(wg); 2305 } 2306 2307 return; 2308 } 2309 2310 /****************************************************************************** 2311 * 2312 * - Nom de la fonction : lecture_parametres_scalaires 2313 * - Description : lecture des parametres scalaires definis 2314 * hors champs et maillages. 2315 * - Parametres : 2316 * - fid (IN) : ID du fichier MED. 2317 * - lecture_en_tete_seule (IN) : mode de lecture. 2318 * 2319 ******************************************************************************/ 2320 2321 void lecture_parametres_scalaires(med_idt fid, 2322 int lecture_en_tete_seulement) 2323 { 2324 med_err ret = 0; 2325 char nom_scalaire[MED_TAILLE_NOM+1]; 2326 char description[MED_TAILLE_DESC+1]; 2327 med_int vali; 2328 med_float valr; 2329 med_int i,n,npdt,j; 2330 med_type_champ type; 2331 med_int numdt,numo; 2332 med_float dt; 2333 char dt_unit[MED_TAILLE_PNOM+1]; 2334 2335 fprintf(stdout,"\n(*******************************)\n"); 2336 fprintf(stdout,"(* VARIABLES SCALAIRES : *)\n"); 2337 fprintf(stdout,"(*******************************)\n"); 2338 2339 /* Combien de variables scalaire ? */ 2340 n = MEDnScalaire(fid); 2341 EXIT_IF(n < 0,"lors de la lecture du nombre de scalaires",NULL); 2342 fprintf(stdout,"- Nombre de variables scalaires : %d\n",n); 2343 2344 if (lecture_en_tete_seulement) 2345 return ; 2346 2347 for (i=1;i<=n;i++) { 2348 2349 /* Lecture des infos (type,description) */ 2350 ret = MEDscalaireInfo(fid,i,nom_scalaire,&type,description); 2351 EXIT_IF(ret < 0,"lors de la lecture des parametres d'un scalaire",NULL); 2352 fprintf(stdout,"- Scalaire n°%d de nom %s \n",i,nom_scalaire); 2353 if (type == MED_FLOAT64) 2354 fprintf(stdout," Type flottant. \n"); 2355 else 2356 fprintf(stdout," Type entier. \n"); 2357 printf(" Description associee : [%s] \n",description); 2358 2359 /* Pour chaque scalaire on regarde les valeurs associees 2360 eventuellement a des pas de temps et des numeros d'ordre */ 2361 npdt = MEDnScalairePasdetemps(fid,nom_scalaire); 2362 EXIT_IF(npdt < 0, 2363 "lors de la lecture du nombre de pas de temps d'un scalaire" 2364 ,NULL); 2365 fprintf(stdout," Nombre de valeurs stockees : %d \n",npdt); 2366 2367 for (j=1;j<=npdt;j++) { 2368 ret = MEDscalairePasdetempsInfo(fid,nom_scalaire,j, 2369 &numdt,dt_unit,&dt,&numo); 2370 EXIT_IF(ret < 0, 2371 "lors de la lecture des parametres d'un pas de temps d'un scalaire", 2372 NULL); 2373 2374 if (numdt == MED_NOPDT) 2375 fprintf(stdout," - Aucun de pas de temps \n"); 2376 else 2377 fprintf(stdout, 2378 " - Pas de de temps de numero %d de valeur %f [%s] \n",numdt, 2379 dt,dt_unit); 2380 if (numo == MED_NONOR) 2381 fprintf(stdout," - Aucun numero d'ordre \n"); 2382 else 2383 fprintf(stdout," - Numero d'ordre : %d \n",numo); 2384 2385 if (type == MED_FLOAT64) { 2386 ret = MEDscalaireFlottantLire(fid,nom_scalaire,&valr,numdt,numo); 2387 fprintf(stdout," - Valeur : %f \n",valr); 2388 } 2389 else { 2390 ret = MEDscalaireEntierLire(fid,nom_scalaire,&vali,numdt,numo); 2391 fprintf(stdout," - Valeur : %d \n",vali); 2392 } 2393 EXIT_IF(ret < 0,"lors de la lecture de la valeur d'un scalaire",NULL); 2394 2395 } 2396 } 2397 2398 return ; 2399 } 2400 2401 2402 med_idt ouverture_fichier_MED(char *fichier) 2403 { 2404 med_idt fid; 2405 med_err ret = 0; 2406 med_int majeur,mineur,release; 2407 2408 /* on regarde si le fichier existe */ 2409 ret = (int) access(fichier,F_OK); 2410 EXIT_IF(ret < 0,"Le fichier n'est pas accessible ou n'existe pas ", 2411 fichier); 2412 2413 /* on regarde s'il s'agit d'un fichier au format HDF 5 */ 2414 ret = MEDformatConforme(fichier); 2415 EXIT_IF(ret < 0,"Le fichier n'est pas au format HDF V5 ", 2416 fichier); 2417 2418 /* Quelle version de MED est utilise par mdump ? */ 2419 MEDversionDonner(&majeur,&mineur,&release); 2420 fprintf(stdout, 2421 "- Lecture du fichier à l'aide de la bibliotheque MED V%d.%d.%d \n", 2422 majeur,mineur,release); 2423 2424 /* Ouverture du fichier MED en lecture seule */ 2425 fid = MEDouvrir(fichier,MED_LECTURE); 2426 EXIT_IF( fid < 0,"Ouverture du du fichier ",fichier); 2427 2428 MEDversionLire(fid, &majeur, &mineur, &release); 2429 EXIT_IF((majeur < 2 || majeur == 2 && mineur < 2), "Le fichier est antérieur à la version 2.2", NULL); 2430 2431 return fid; 2432 } 2433 2434 void lecture_en_tete(med_idt fid,char* fichier) 2435 { 2436 med_int long_fichier_en_tete; 2437 char *fichier_en_tete; 2438 med_err ret = 0; 2439 2440 /* lecture de l'en-tete du fichier (optionnel) */ 2441 long_fichier_en_tete = MEDlFichDes(fid); 2442 if (long_fichier_en_tete > 0) { 2443 fichier_en_tete = (char *) malloc(sizeof(char)*(long_fichier_en_tete+1)); 2444 EXIT_IF(fichier_en_tete == NULL,NULL,NULL); 2445 2446 /* on va lire dans le fichier */ 2447 ret = MEDfichEntete(fid,MED_FICH_DES,fichier_en_tete); 2448 EXIT_IF(ret < 0,"lecture de l'en-tete du fichier",fichier); 2449 2450 /* on affiche */ 2451 fprintf(stdout,"- En-tete du fichier : %s \n",fichier_en_tete); 2452 2453 /* on libere la memoire */ 2454 free(fichier_en_tete); 2455 } 2456 2457 return; 2458 } 2459 2460 void parametrage(med_mode_switch *mode_coo, 2461 med_connectivite *typ_con) 2462 { 2463 int reponse; 2464 2465 fprintf(stdout,"(*****************)\n"); 2466 fprintf(stdout,"(* PARAMETRAGE : *)\n"); 2467 fprintf(stdout,"(*****************)\n"); 2468 fprintf(stdout,"- Mode d'affichage des coordonnées des noeuds ? \n"); 2469 fprintf(stdout," 1. Mode entrelacé : taper 1 \n"); 2470 fprintf(stdout," 2. Mode non entrelacé : taper 2 \n"); 2471 reponse = 0; 2472 do { 2473 fprintf(stdout," Reponse : "); 2474 scanf("%d",&reponse); 2475 } while (reponse != 1 && reponse != 2); 2476 if (reponse == 1) 2477 *mode_coo = MED_FULL_INTERLACE; 2478 else 2479 *mode_coo = MED_NO_INTERLACE; 2480 2481 fprintf(stdout,"- Connectivité des éléments ? \n"); 2482 fprintf(stdout," 1. Nodale : taper 1 \n"); 2483 fprintf(stdout," 2. Descendante : taper 2 \n"); 2484 reponse = 0; 2485 do { 2486 fprintf(stdout," Reponse : "); 2487 scanf("%d",&reponse); 2488 } while (reponse != 1 && reponse != 2); 2489 if (reponse == 1) 2490 *typ_con = MED_NOD; 2491 else 2492 *typ_con = MED_DESC; 2493 2494 return; 2495 } 2496 2497 2498 void lecture_information_maillage(med_idt fid, 2499 int numero, 2500 char *nommaa, 2501 med_int *mdim, 2502 med_maillage *type_maillage, 2503 char *maillage_description) 2504 { 2505 med_int edim; 2506 char nom_universel[MED_TAILLE_LNOM+1]; 2507 med_err ret = 0; 2508 2509 fprintf(stdout,"\n(********************************************)\n"); 2510 fprintf(stdout,"(* INFORMATIONS GENERALES SUR LE MAILLAGE : *)\n"); 2511 fprintf(stdout,"(********************************************)\n"); 2512 2513 /* lecture du nom et de la dimension du maillage */ 2514 ret = MEDmaaInfo(fid,numero,nommaa,mdim,type_maillage,maillage_description); 2515 EXIT_IF(ret < 0,"Lecture des informations sur le maillage",NULL); 2516 2517 /* lecture de la dimension de l'espace de calcul */ 2518 edim = MEDdimEspaceLire(fid,nommaa); 2519 2520 /* affichage des donnees lues */ 2521 fprintf(stdout,"- Nom du maillage : <<%s>>\n",nommaa); 2522 fprintf(stdout,"- Dimension du maillage : %d\n",*mdim); 2523 if (edim > *mdim) 2524 fprintf(stdout,"- La dimension de l'espace est %d \n",edim); 2525 if (*type_maillage == MED_NON_STRUCTURE) 2526 fprintf(stdout,"- Type du maillage : MED_NON_STRUCTURE \n"); 2527 else 2528 fprintf(stdout,"- Type du maillage : MED_STRUCTURE \n"); 2529 fprintf(stdout,"- Description associee au maillage : %s\n", 2530 maillage_description); 2531 2532 /* lecture du nom universel (presence optionnelle) */ 2533 ret = MEDunvLire(fid,nommaa,nom_universel); 2534 if (ret == 0) 2535 fprintf(stdout,"- Nom universel du maillage : %s \n",nom_universel); 2536 2537 return; 2538 } 2539 2540 /****************************************************************************** 2541 * 2542 * - Nom de la fonction : main 2543 * - Description : fonction "main" de l'outil de DUMP d'un fichier MED. 2544 * - Parametres : 2545 * - argc (IN) : nombre d'arguments sur la ligne de commande. 2546 * - argv (IN) : liste des arguments. 2547 * 2548 ******************************************************************************/ 2549 2550 int main (int argc, char **argv) 2551 { 2552 med_err ret = 0; 2553 med_idt fid; 2554 int i; 2555 int numero; 2556 med_mode_switch mode_coo; 2557 med_connectivite typ_con; 2558 int lecture_en_tete_seulement = 0; 2559 char version_hdf[10]; 2560 char version_med[10]; 2561 med_int mdim,nmaa; 2562 /* nom du maillage */ 2563 char nommaa[MED_TAILLE_NOM+1]; 2564 char maillage_description[MED_TAILLE_DESC+1]; 2565 med_maillage type_maillage; 2566 med_int edim; 2567 med_int majeur_lu,mineur_lu,release_lu; 2568 med_int nprofils; 2569 int decalage; 2570 2571 /**************************************************************************** 2572 * TEST DU NOMBRE D'ARGUMENTS * 2573 * argument 1 = nom du fichier MED * 2574 ****************************************************************************/ 2575 2576 structure = 0; 2577 decalage = 0; 2578 if (argc > 2 && strcmp(argv[1], "--structure") == 0) { 2579 argc--; 2580 decalage = 1; 2581 structure = 1; 2582 } 2583 2584 EXIT_IF(argc != 2 && argc != 5,"nombre de parametres incorrects\n",NULL); 2585 2586 2587 /**************************************************************************** 2588 * OUVERTURE DU FICHIER EN LECTURE * 2589 ****************************************************************************/ 2590 fid = ouverture_fichier_MED(argv[1 + decalage]); 2591 2592 2593 /**************************************************************************** 2594 * QUESTIONS PRELIMINAIRES * 2595 * 1. Mode d'affichage des coordonnees (entrelace ou non) ? * 2596 * 2. Connectivite des elements (nodale ou descendante) ? * 2597 ***************************************************************************/ 2598 fprintf(stdout,"\n >>>>>> DUMP DU FICHIER %s >>>>>>\n",argv[1 + decalage]); 2599 2600 /* lecture et affichage de l'en-tete du fichier */ 2601 lecture_en_tete(fid,argv[1 + decalage]); 2602 2603 if (argc == 2) 2604 parametrage(&mode_coo,&typ_con); 2605 else { 2606 if (! strcmp(argv[3 + decalage],"NODALE")) 2607 typ_con = MED_NOD; 2608 if (! strcmp(argv[3 + decalage],"DESCENDANTE")) 2609 typ_con = MED_DESC; 2610 2611 if (!strcmp(argv[4 + decalage],"NO_INTERLACE")) 2612 mode_coo = MED_NO_INTERLACE; 2613 if (!strcmp(argv[4 + decalage],"FULL_INTERLACE")) 2614 mode_coo = MED_FULL_INTERLACE; 2615 if (! strcmp(argv[4 + decalage],"LECTURE_EN_TETE_SEULEMENT")) 2616 lecture_en_tete_seulement = 1; 2617 } 2618 2619 2620 /**************************************************************************** 2621 * QUEL MAILLAGE LIRE ? * 2622 ***************************************************************************/ 2623 nmaa = MEDnMaa(fid); 2624 EXIT_IF(nmaa < 0,"lors de la lecture du nombre de maillages",NULL); 2625 2626 /* Quel maillage lire ? */ 2627 if (argc == 2) { 2628 fprintf(stdout,"- Il y a %d maillages dans ce fichier \n",nmaa); 2629 fprintf(stdout," Lequel voulez-vous lire (1|2|3|...|n) ?\n"); 2630 do { 2631 fprintf(stdout," Reponse : "); 2632 scanf("%d",&numero); 2633 } while (numero > nmaa || numero <= 0); 2634 } 2635 else { 2636 numero = atoi(argv[2 + decalage]); 2637 EXIT_IF(numero > nmaa || numero <= 0,"ce numero de maillage n'existe pas", 2638 NULL); 2639 } 2640 2641 /**************************************************************************** 2642 * PARAMETRES SCALAIRES * 2643 ****************************************************************************/ 2644 2645 /* on va lire l'ensemble des parametres scalaire */ 2646 lecture_parametres_scalaires(fid,lecture_en_tete_seulement); 2647 2648 /**************************************************************************** 2649 * INFOS GENERALES SUR LE MAILLAGE * 2650 ****************************************************************************/ 2651 lecture_information_maillage(fid,numero,nommaa,&mdim,&type_maillage, 2652 maillage_description); 2653 2654 2655 /**************************************************************************** 2656 * LECTURE DU MAILLAGE ET DES RESULTATS ASSOCIES * 2657 ****************************************************************************/ 2658 if (type_maillage == MED_NON_STRUCTURE) 2659 lecture_maillage_non_structure(fid,nommaa,mdim,mode_coo,typ_con, 2660 lecture_en_tete_seulement); 2661 else 2662 lecture_maillage_structure(fid,nommaa,mdim,mode_coo, 2663 lecture_en_tete_seulement); 2664 2665 /* on lit ensuite les resultats associes au maillage selectionne */ 2666 lecture_resultats(fid,nommaa,mode_coo,lecture_en_tete_seulement); 2667 2668 /**************************************************************************** 2669 * FERMETURE DU FICHIER * 2670 ****************************************************************************/ 2671 ret = MEDfermer(fid); 2672 EXIT_IF(ret < 0,"lors de la fermeture du fichier",argv[1 + decalage]); 2673 2674 fprintf(stdout,"\n >>>>>> FIN DU DUMP DU FICHIER %s >>>>>>\n",argv[1 + decalage]); 2675 2676 return EXIT_SUCCESS; 2677 }