# mdump.c

Aller à la documentation de ce fichier.

    00001 /*  This file is part of MED.
    00002  *
    00003  *  COPYRIGHT (C) 1999 - 2011  EDF R&D, CEA/DEN
    00004  *  MED is free software: you can redistribute it and/or modify
    00005  *  it under the terms of the GNU Lesser General Public License as published by
    00006  *  the Free Software Foundation, either version 3 of the License, or
    00007  *  (at your option) any later version.
    00008  *
    00009  *  MED is distributed in the hope that it will be useful,
    00010  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
    00011  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    00012  *  GNU Lesser General Public License for more details.
    00013  *
    00014  *  You should have received a copy of the GNU Lesser General Public License
    00015  *  along with MED.  If not, see <http://www.gnu.org/licenses/>.
    00016  */
    00017
    00018 /******************************************************************************
    00019  * - Nom du fichier : mdump.c
    00020  *
    00021  * - Description : utilitaire de dump pour fichier MED
    00022  *                 Ce fichier contient les fonctions suivantes
    00023  *                 qui constituent des modeles de programmation
    00024  *                 pour une lecture generique d'un fichier MED :
    00025  *                 - lecture_maillage_non_structure () :
    00026  *                        1. Noeuds.
    00027  *                        2. Mailles.
    00028  *                        3. Faces (connectivite descendante).
    00029  *                        4. Aretes (connectivite descendante).
    00030  *                        5. Familles.
    00031  *                        6. Equivalences.
    00032  *                        7. Joints.
    00033  *                 - lecture_maillage_structure ()     :
    00034  *                        1. Noeuds.
    00035  *                        2. Mailles.
    00036  *                        3. Familles.
    00037  *                        4. Equivalences.
    00038  *                        5. Joints.
    00039  *                 - lecture_resultats () :
    00040  *                        1. Champs de resultats relatifs à un maillage.
    00041  *                           - Entites :
    00042  *                                - Noeuds
    00043  *                                - Mailles
    00044  *                                - Faces
    00045  *                                - Aretes
    00046  *                           - Gestion des pas de temps et numeros d'ordre :
    00047  *                                  valeurs associees a un ou plusieurs maillages sous
    00048  *                                  un meme pas de temps.
    00049  *                           - Gestion des profils.
    00050  *                           - Gestion des liens vers des maillages distants
    00051  *                           - Gestion des points de Gauss :
    00052  *                                - localisation des points de Gauss.
    00053  *                 - lecture_parametres_scalaires () :
    00054  *                           - Valeurs scalaires entieres ou flottantes.
    00055  *                           - Gestion des pas de temps et numeros d'ordre.
    00056  *                 - main() : infos generales + lecture de tous les champs et
    00057  *                            du fichier MED passe en parametre.
    00058  *
    00059  *****************************************************************************/
    00060
    00061 #ifndef MESGERR
    00062 #define MESGERR 1
    00063 #endif
    00064
    00065 #ifdef __cplusplus
    00066 extern "C" {
    00067 #endif
    00068
    00069 #include <med.h>
    00070 #include <med_config.h>
    00071 #include <med_utils.h>
    00072 #include <med_misc.h>
    00073 #include <stdio.h>
    00074 #include <string.h>
    00075 #include <stdlib.h>
    00076
    00077 #ifdef __cplusplus
    00078 }
    00079 #endif
    00080
    00081 #ifdef PPRO_NT
    00082 #define F_OK 0
    00083 #else
    00084 #include <unistd.h>
    00085 #endif
    00086
    00087
    00088 extern med_entity_type MED23MESH_GET_ENTITY_TYPE[MED_N_ENTITY_TYPES+2];
    00089 extern const char * const MED23MESH_GET_ENTITY_TYPENAME[MED_N_ENTITY_TYPES+2];
    00090 extern med_geometry_type MED23MESH_GET_CELL_GEOMETRY_TYPE[MED_N_CELL_FIXED_GEO+2];
    00091 extern const char * const MED23MESH_GET_CELL_GEOMETRY_TYPENAME[MED_N_CELL_FIXED_GEO+2];
    00092 extern med_geometry_type MED23MESH_GET_FACE_GEOMETRY_TYPE[MED_N_FACE_FIXED_GEO+2];
    00093 extern const char * const MED23MESH_GET_FACE_GEOMETRY_TYPENAME[MED_N_FACE_FIXED_GEO+2];
    00094 extern med_geometry_type MED23MESH_GET_EDGE_GEOMETRY_TYPE[MED_N_EDGE_FIXED_GEO+2];
    00095 extern const char * MED23MESH_GET_EDGE_GEOMETRY_TYPENAME[MED_N_EDGE_FIXED_GEO+2];
    00096 extern med_geometry_type MED23MESH_GET_NODE_GEOMETRY_TYPE[MED_N_NODE_FIXED_GEO+2];
    00097 extern const char * MED23MESH_GET_NODE_GEOMETRY_TYPENAME[MED_N_NODE_FIXED_GEO+2];
    00098
    00099 extern med_entity_type MED23FIELD_GET_ENTITY_TYPE[MED_N_ENTITY_TYPES+2];
    00100 extern const char * const MED23FIELD_GET_ENTITY_TYPENAME[MED_N_ENTITY_TYPES+2];
    00101 extern med_geometry_type MED23FIELD_GET_CELL_GEOMETRY_TYPE[MED_N_CELL_FIXED_GEO+2];
    00102 extern const char * const MED23FIELD_GET_CELL_GEOMETRY_TYPENAME[MED_N_CELL_FIXED_GEO+2];
    00103 extern med_geometry_type MED23FIELD_GET_FACE_GEOMETRY_TYPE[MED_N_FACE_FIXED_GEO+2];
    00104 extern const char * const MED23FIELD_GET_FACE_GEOMETRY_TYPENAME[MED_N_FACE_FIXED_GEO+2];
    00105 extern med_geometry_type MED23FIELD_GET_EDGE_GEOMETRY_TYPE[MED_N_EDGE_FIXED_GEO+2];
    00106 extern const char * MED23FIELD_GET_EDGE_GEOMETRY_TYPENAME[MED_N_EDGE_FIXED_GEO+2];
    00107 extern med_geometry_type MED23FIELD_GET_NODE_GEOMETRY_TYPE[MED_N_NODE_FIXED_GEO+2];
    00108 extern const char * MED23FIELD_GET_NODE_GEOMETRY_TYPENAME[MED_N_NODE_FIXED_GEO+2];
    00109
    00110
    00111 /* indique si on ecrit seulement la structure */
    00112 int structure = 0;
    00113
    00114 /* types geometriques des mailles references dans le modele MED */
    00115 const med_geometry_type * const typmai = MED23MESH_GET_CELL_GEOMETRY_TYPE+1;
    00116 const med_geometry_type * const typfac = MED23MESH_GET_FACE_GEOMETRY_TYPE+1;
    00117 const med_geometry_type * const typare = MED23MESH_GET_EDGE_GEOMETRY_TYPE+1;
    00118
    00119 const char * const *nommai = MED23MESH_GET_CELL_GEOMETRY_TYPENAME+1;
    00120 const char * const *nomfac = MED23MESH_GET_FACE_GEOMETRY_TYPENAME+1;
    00121 const char * const *nomare = MED23MESH_GET_EDGE_GEOMETRY_TYPENAME+1;
    00122
    00123
    00124 #define USER_MODE MED_COMPACT_STMODE
    00125
    00126 #define xstr(s) str(s)
    00127 #define str(s) #s
    00128
    00129 med_int lecture_nombre_famille(med_idt fid,const char * const nommaa)
    00130 {
    00131   med_int nfam = MEDnFamily(fid,nommaa);
    00132   EXIT_IF(nfam < 0,"lors de la lecture du nombre de familles",NULL);
    00133   fprintf(stdout,"- Nombre de familles : %d \n",nfam);
    00134
    00135   return nfam;
    00136 }
    00137
    00138 void lecture_famille_maillage(med_idt fid,const char * const nommaa,med_int nfam)
    00139 {
    00140   med_int i,j;
    00141   med_int natt,ngro;
    00142   char *attdes=NULL,*gro=NULL;
    00143   med_int *attval=NULL,*attide=NULL;
    00144   char nomfam[MED_NAME_SIZE+1];
    00145   med_int numfam;
    00146   char str1[MED_COMMENT_SIZE+1];
    00147   char str2[MED_LNAME_SIZE+1];
    00148   med_err ret = 0;
    00149   int famille_0 = 0;
    00150
    00151   fprintf(stdout,"\n(**************************)\n");
    00152   fprintf(stdout,"(* FAMILLES DU MAILLAGE : *)\n");
    00153   fprintf(stdout,"(**************************)\n");
    00154
    00155   for (i=0;i<nfam;i++) {
    00156
    00157     /* nombre de groupes */
    00158     ngro = MEDnFamilyGroup(fid,nommaa,i+1);
    00159     EXIT_IF(ngro < 0,"lors de la lecture du nombre de groupe d'une famille",
    00160             NULL);
    00161
    00162     /* nombre d'attributs */
    00163     natt = MEDnFamily23Attribute(fid,nommaa,i+1);
    00164     EXIT_IF(natt < 0,"lors de la lecture du nombre d'attributs d'une famille",
    00165             NULL);
    00166
    00167     fprintf(stdout,"- Famille %d a %d attributs et %d groupes \n",i+1,natt,
    00168             ngro);
    00169
    00170     /* nom,numero,attributs,groupes */
    00171
    00172     /* allocation memoire */
    00173     attide = (med_int*) malloc(sizeof(med_int)*natt);
    00174     EXIT_IF(attide == NULL,NULL,NULL);
    00175     attval = (med_int*) malloc(sizeof(med_int)*natt);
    00176     EXIT_IF(attval == NULL,NULL,NULL);
    00177     attdes = (char *) malloc(MED_COMMENT_SIZE*natt+1);
    00178     EXIT_IF(attdes == NULL,NULL,NULL);
    00179     gro = (char*) malloc(MED_LNAME_SIZE*ngro+1);
    00180     EXIT_IF(gro == NULL,NULL,NULL);
    00181     ret = MEDfamily23Info(fid,nommaa,i+1,nomfam,attide,attval,
    00182                           attdes,&numfam,gro);
    00183     EXIT_IF(ret < 0,"lors de la lecture des informations d'une famille",
    00184             NULL);
    00185         if (numfam == 0)
    00186           famille_0 = 1;
    00187
    00188     if (!structure) {
    00189     /* affichage des resultats */
    00190     fprintf(stdout,"  - Famille de nom %s et de numero %d : \n",nomfam,numfam);
    00191     fprintf(stdout,"  - Attributs : \n");
    00192     for (j=0;j<natt;j++) {
    00193       strncpy(str1,attdes+j*MED_COMMENT_SIZE,MED_COMMENT_SIZE);
    00194       str1[MED_COMMENT_SIZE] = '\0';
    00195       fprintf(stdout,"   ide = %d - val = %d - des = %s\n",*(attide+j),
    00196               *(attval+j),str1);
    00197     }
    00198     }
    00199
    00200     /* on libere la memoire */
    00201     if (attide) {free(attide);attide=NULL;}
    00202     if (attval) {free(attval);attval=NULL;}
    00203     if (attdes) {free(attdes);attdes=NULL;}
    00204
    00205     if (!structure) {
    00206     fprintf(stdout,"  - Groupes :\n");
    00207     for (j=0;j<ngro;j++) {
    00208       strncpy(str2,gro+j*MED_LNAME_SIZE,MED_LNAME_SIZE);
    00209       str2[MED_LNAME_SIZE] = '\0';
    00210       fprintf(stdout,"   gro = %s\n",str2);
    00211     }
    00212     }
    00213
    00214     /* on libere la memoire */
    00215     if (gro) {free(gro);gro=NULL;}
    00216   }
    00217
    00218   if (famille_0 != 1) {
    00219     MESSAGE("Erreur : La famille FAMILLE_ZERO n'a pas été trouvée, elle est obligatoire. ");
    00220   }
    00221
    00222   return;
    00223 }
    00224
    00225 med_int lecture_nombre_equivalence(med_idt fid,const char * const nommaa)
    00226 {
    00227   med_int nequ = MEDnEquivalence(fid,nommaa);
    00228   EXIT_IF(nequ < 0,"lors de la lecture du nombre d'equivalences",NULL);
    00229   fprintf(stdout,"- Nombre d'equivalences : %d \n",nequ);
    00230
    00231   return nequ;
    00232 }
    00233
    00234 /* nombre de mailles concernees par les equivalences */
    00235 void lecture_equivalence_maillage(med_idt fid,const char * const nommaa,med_int nequ)
    00236 {
    00237   med_int i,j,k;
    00238   med_int ncor;
    00239   med_int *cor;
    00240   char equ[MED_NAME_SIZE+1];
    00241   char des[MED_COMMENT_SIZE+1];
    00242   med_err ret = 0;
    00243   med_int nstep=0,nocstpncor=0;
    00244   int     _cstpit=0;
    00245   med_int _numdt,_numit;
    00246
    00247   fprintf(stdout,"\n(******************************)\n");
    00248   fprintf(stdout,"(* EQUIVALENCES DU MAILLAGE : *)\n");
    00249   fprintf(stdout,"(******************************)\n");
    00250
    00251   if (nequ == 0)
    00252     fprintf(stdout,"- Aucune équivalence \n");
    00253
    00254   /* lecture de toutes les equivalences associes a nommaa */
    00255   for (i = 0;i<nequ;i++) {
    00256     fprintf(stdout,"- Equivalence numero : %d ",i+1);
    00257
    00258     /* lecture des infos sur l'equivalence */
    00259     ret = MEDequivalenceInfo(fid,nommaa,i+1,equ,des,&nstep,&nocstpncor);
    00260     EXIT_IF(ret < 0,"lors de la lecture des informations sur une equivalence",
    00261             NULL);
    00262     fprintf(stdout,"\n  - Nom de l'equivalence: %s \n",equ);
    00263     fprintf(stdout,"\n  - Description de l'equivalence : %s \n",des);
    00264     if (nstep > 1)
    00265       fprintf(stdout,"\n  - L'equivalence est définie sur "IFORMAT" étapes de calcul\n",nstep);
    00266
    00267     for (_cstpit=1; _cstpit <= nstep; ++_cstpit) {
    00268
    00269       ret = MEDequivalenceComputingStepInfo   (fid, nommaa, equ, _cstpit,
    00270                                                & _numdt, &_numit,&nocstpncor);
    00271       EXIT_IF(ret < 0,
    00272               "lors de la lecture des valeurs de séquence de calcul  d'une equivalence",
    00273               NULL);
    00274       if ( (_numdt != MED_NO_DT) || (_numit != MED_NO_IT) )
    00275         fprintf(stdout,"\n  - Séquence de calcul définie sur (numdt,numit) ("IFORMAT","IFORMAT") :\n",_numdt,_numit);
    00276
    00277       /* lecture des correspondances sur les differents types d'entites */
    00278
    00279       /* les noeuds */
    00280       ret = MEDequivalenceCorrespondenceSize(fid,nommaa,equ,_numdt,_numit,MED_NODE,MED_NONE,&ncor);
    00281       EXIT_IF(ret < 0,
    00282               "lors de la lecture du nombre de correspondances d'une equivalence",
    00283               NULL);
    00284       fprintf(stdout,"\n  - Il y a %d correspondances sur les noeuds \n",ncor);
    00285
    00286       if (ncor > 0) {
    00287
    00288         /* allocation memoire */
    00289         cor = (med_int*) malloc(sizeof(med_int)*ncor*2);
    00290         EXIT_IF(cor == NULL,NULL,NULL);
    00291         ret= MEDequivalenceCorrespondenceRd(fid,nommaa,equ,_numdt,_numit,
    00292                                             MED_NODE,MED_NONE,cor);
    00293         EXIT_IF(ret < 0,"lors de la lecture du tableau des correspondances",
    00294                 NULL);
    00295         if (!structure) {
    00296           for (j=0;j<ncor;j++)
    00297             fprintf(stdout,"\n  - Correspondance %d : %d et %d \n",j+1,*(cor+2*j),
    00298                     *(cor+2*j+1));
    00299         }
    00300         free(cor);
    00301       }
    00302
    00303       /* sur les mailles : */
    00304       for (j=0;j<MED_N_CELL_FIXED_GEO;j++) {
    00305
    00306         ret = MEDequivalenceCorrespondenceSize(fid,nommaa,equ,_numdt,_numit,MED_CELL,typmai[j],&ncor);
    00307         EXIT_IF(ret < 0,
    00308                 "lors de la lecture du nombre de correspondances dans une equivalence",
    00309                 NULL);
    00310         fprintf(stdout,"\n  - Il y a %d correspondances sur les mailles %s \n",ncor,
    00311                 nommai[j]);
    00312
    00313         if (ncor > 0) {
    00314
    00315           /* allocation memoire */
    00316           cor = (med_int*) malloc(sizeof(med_int)*ncor*2);
    00317           EXIT_IF(cor == NULL,NULL,NULL);
    00318           ret = MEDequivalenceCorrespondenceRd(fid,nommaa,equ,_numdt,_numit,
    00319                                                MED_CELL,typmai[j],cor);
    00320           EXIT_IF(ret < 0,"lors de la lecture du tableau des equivalences",
    00321                   NULL);
    00322
    00323           if (!structure) {
    00324             for (k=0;k<ncor;k++)
    00325               fprintf(stdout,"\n  - Correspondance %d : %d et %d \n",k+1,
    00326                       *(cor+2*k),*(cor+2*k+1));
    00327           }
    00328           free(cor);
    00329         }
    00330       }
    00331
    00332
    00333       /* sur les faces */
    00334       for (j=0;j<MED_N_FACE_FIXED_GEO;j++) {
    00335
    00336         ret = MEDequivalenceCorrespondenceSize(fid,nommaa,equ,_numdt,_numit,
    00337                                                MED_DESCENDING_FACE,typfac[j],&ncor);
    00338
    00339         EXIT_IF(ret < 0,
    00340                 "lors de la lecture du nombre de correspondances dans une equivalence",
    00341                 NULL);
    00342         fprintf(stdout,"\n  - Il y a %d correspondances sur les faces %s\n",ncor,
    00343               nomfac[j]);
    00344
    00345         if (ncor > 0) {
    00346
    00347           /* allocation memoire */
    00348           cor = (med_int*) malloc(sizeof(med_int)*ncor*2);
    00349           EXIT_IF(cor == NULL,NULL,NULL);
    00350           ret = MEDequivalenceCorrespondenceRd(fid,nommaa,equ,_numdt,_numit,
    00351                                                MED_DESCENDING_FACE,typfac[j],cor);
    00352           EXIT_IF(ret < 0,"lors de la lecture du tableau des equivalences",
    00353                   NULL);
    00354
    00355           if (!structure) {
    00356             for (k=0;k<ncor;k++)
    00357               fprintf(stdout,"\n  - Correspondance %d : %d et %d \n",k+1,*(cor+2*k),
    00358                       *(cor+2*k+1));
    00359           }
    00360           free(cor);
    00361         }
    00362       }
    00363
    00364
    00365       /*  sur les aretes */
    00366       for (j=0;j<MED_N_NODE_FIXED_GEO;j++) {
    00367
    00368         ret = MEDequivalenceCorrespondenceSize(fid,nommaa,equ,_numdt,_numit,
    00369                                              MED_DESCENDING_EDGE,typare[j],&ncor);
    00370         EXIT_IF(ret < 0,"lors de la lecture du nombre de correspondances",
    00371                 NULL);
    00372         fprintf(stdout,"\n  - Il y a %d correspondances sur les aretes %s \n",
    00373                 ncor,nomare[j]);
    00374
    00375         if (ncor > 0) {
    00376
    00377           /* allocation memoire */
    00378           cor = (med_int*) malloc(sizeof(med_int)*ncor*2);
    00379           EXIT_IF(cor == NULL,NULL,NULL);
    00380           ret =MEDequivalenceCorrespondenceRd(fid,nommaa,equ,_numdt,_numit,
    00381                                               MED_DESCENDING_EDGE,typare[j],cor);
    00382           EXIT_IF(ret < 0,"lors de la lecture du tableau des equivalences",
    00383                   NULL);
    00384
    00385           if (!structure) {
    00386             for (k=0;k<ncor;k++)
    00387               fprintf(stdout,"\n  Correspondance %d : %d et %d \n",k+1,*(cor+2*k),
    00388                       *(cor+2*k+1));
    00389           }
    00390
    00391           free(cor);
    00392         }
    00393       }
    00394     }
    00395   }
    00396
    00397   return;
    00398 }
    00399
    00400
    00401 med_int lecture_nombre_joint(med_idt fid,const char * const nommaa)
    00402 {
    00403   med_int njnt = MEDnSubdomainJoint(fid,nommaa);
    00404   EXIT_IF(njnt < 0,"lors de la lecture du nombre de joints",NULL);
    00405   fprintf(stdout,"- Nombre de joints : %d \n",njnt);
    00406
    00407   return njnt;
    00408 }
    00409
    00410
    00411 void lecture_joint_maillage(med_idt fid,const char * const nommaa,med_int njnt)
    00412 {
    00413   med_int i,k;
    00414   char des[MED_COMMENT_SIZE+1];
    00415   med_int ndom,nent;
    00416   med_int typ_ent_local,typ_geo_local,typ_ent_distant,typ_geo_distant;
    00417 /*   med_int geo_ent_local,geo_ent_distant; */
    00418
    00419   char jn                  [MED_NAME_SIZE+1]="";
    00420   char maa_dist            [MED_NAME_SIZE+1]="";
    00421   char nom_geo_ent_local   [MED_NAME_SIZE+1]="";
    00422   char nom_geo_ent_distant [MED_NAME_SIZE+1]="";
    00423   med_int *cortab;
    00424
    00425   med_err ret = 0;
    00426   med_int njstep=0,ncor=0,nodtitncor=0;
    00427   int corit=0,csit=0;
    00428   med_int _numdt,_numit;
    00429
    00430   fprintf(stdout,"\n(******************************)\n");
    00431   fprintf(stdout,"(* JOINTS DU MAILLAGE       : *)\n");
    00432   fprintf(stdout,"(******************************)\n");
    00433
    00434   if (njnt == 0)
    00435     fprintf(stdout,"- Aucun joint \n");
    00436
    00437   /* lecture de touts les joints associes a nommaa */
    00438   for (i = 0;i<njnt;i++) {
    00439     fprintf(stdout,"- Joint numero : %d ",i+1);
    00440
    00441     /* lecture des infos sur le joint */
    00442     ret = MEDsubdomainJointInfo(fid,nommaa,i+1,jn,des,&ndom,maa_dist,&njstep,&nodtitncor);
    00443     EXIT_IF(ret < 0,"lors de la lecture des informations sur un joint",
    00444             NULL);
    00445
    00446     fprintf(stdout,"\n  - Nom du joint: %s \n",jn);
    00447     fprintf(stdout,"\n  - Description du joint      : %s ",des);
    00448     fprintf(stdout,"\n  - Domaine en regard         : %d ",ndom);
    00449     fprintf(stdout,"\n  - Maillage distant          : %s ",maa_dist);
    00450     if (njstep > 1 ) {
    00451       printf("Nombre d'étapes de calcul : "IFORMAT" \n",njstep);
    00452       printf("Nombre de correspondance pour (NO_DT,NO_IT) : "IFORMAT" \n",nodtitncor);
    00453     }
    00454
    00455     for (csit=1; csit <= njstep; ++csit) {
    00456
    00457       ret = MEDsubdomainComputingStepInfo( fid, nommaa, jn, csit, &_numdt, &_numit, &ncor);
    00458       EXIT_IF(ret < 0,"Erreur a la lecture des valeurs (numdt,numit) dans les joints",
    00459             NULL);
    00460       if ( (_numdt != MED_NO_DT) || (_numit != MED_NO_IT) ) {
    00461         printf("Séquence de calcul (numdt,numit) : ("IFORMAT","IFORMAT")\n",_numdt,_numit);
    00462       }
    00463       corit=1;
    00464       while ( corit <= ncor ) {
    00465
    00466         ret = MEDsubdomainCorrespondenceSizeInfo(fid,nommaa,jn,_numdt,_numit,corit,
    00467                                                  (med_entity_type *) &typ_ent_local, (med_geometry_type *) &typ_geo_local,
    00468                                                  (med_entity_type *) &typ_ent_distant,(med_geometry_type *)&typ_geo_distant,
    00469                                                  &nent);
    00470         EXIT_IF(ret < 0,"Erreur a la lecture des infos sur le nombre d'entite en regard",
    00471                 NULL);
    00472         if (nent > 0) {
    00473           if (typ_ent_local == MED_NODE) strcpy(nom_geo_ent_local,"MED_NOEUD");
    00474           else  ret = _MEDgetExternalGeometryTypeName(nom_geo_ent_local,typ_geo_local);
    00475           EXIT_IF(ret < 0,"Erreur à l'appel de _MEDgetExternalGeometryTypeName", NULL);
    00476           if (typ_ent_distant == MED_NODE) strcpy(nom_geo_ent_distant,"MED_NOEUD");
    00477           else ret = _MEDgetExternalGeometryTypeName(nom_geo_ent_distant,typ_geo_distant);
    00478           EXIT_IF(ret < 0,"Erreur à l'appel de _MEDgetExternalGeometryTypeName", NULL);
    00479           fprintf(stdout,"\n\t\t- nb de couples d'entites en regard (local,distant)=(%s,%s) : "IFORMAT" \n",
    00480                   nom_geo_ent_local,nom_geo_ent_distant,  nent);
    00481           /*TODO : Supprimer la ligne suivante*/
    00482 /*        fprintf(stdout,"  %d \n",nent); */
    00483           cortab = (med_int*) malloc(sizeof(med_int)*nent*2);
    00484           if ( (ret=MEDsubdomainCorrespondenceRd(fid,nommaa,jn,_numdt,_numit,
    00485                                                  typ_ent_local,typ_geo_local,typ_ent_distant,typ_geo_distant,
    00486                                                  cortab)) < 0) {
    00487             fprintf(stdout,"\n\t\t- Erreur a la lecture des correspondances sur (%s,%s,%s,%s)",
    00488                     MED23MESH_GET_ENTITY_TYPENAME[typ_ent_local+1],nom_geo_ent_local,
    00489                     MED23MESH_GET_ENTITY_TYPENAME[typ_ent_distant+1],nom_geo_ent_distant);
    00490           } else {
    00491             if (!structure) {
    00492               for (k=0;k<nent;k++)
    00493                 fprintf(stdout,"\n\t\t- Correspondance %d : "IFORMAT" et "IFORMAT" ",k+1,
    00494                         *(cortab+2*k),*(cortab+2*k+1));
    00495             }
    00496           }
    00497           free(cortab);
    00498         }
    00499
    00500         corit++;
    00501       }
    00502     }
    00503   }
    00504
    00505   return;
    00506 }
    00507
    00508
    00509 med_int lecture_nombre_noeuds_maillage_non_structure(const med_idt fid,
    00510                                                      const char *  nommaa,
    00511                                                      const med_int numdt,
    00512                                                      const med_int numit)
    00513 {
    00514
    00515
    00516   med_bool chgt=MED_FALSE,trsf=MED_FALSE;
    00517
    00518   med_int nnoe = MEDmeshnEntity(fid,nommaa,numdt,numit,
    00519                                 MED_NODE,MED_NO_GEOTYPE,
    00520                                 MED_COORDINATE,MED_NODAL,&chgt,&trsf);
    00521   EXIT_IF(nnoe < 0,"lors de la lecture du nombre de noeuds",NULL);
    00522   fprintf(stdout,"- Nombre de noeuds : %d \n",nnoe);
    00523
    00524   return nnoe;
    00525 }
    00526
    00527
    00528 void lecture_noeuds_maillage_non_structure(const med_idt fid,
    00529                                            const char * const nommaa,
    00530                                            const med_int numdt,
    00531                                            const med_int numit,
    00532                                            const med_int mdim,
    00533                                            const med_int edim,
    00534                                            const med_int nnoe,
    00535                                            const med_switch_mode mode_coo,
    00536                                            const char * const nomcoo,
    00537                                            const char * const unicoo,
    00538                                            const med_axis_type *const rep)
    00539 {
    00540   med_float *coo;
    00541   char *nomnoe;
    00542   med_int *numnoe;
    00543   med_int *nufano;
    00544   med_bool inonoe,inunoe,ifano;
    00545   med_err ret = 0;
    00546   med_int i;
    00547   char str[MED_SNAME_SIZE+1];
    00548
    00549
    00550   /* Allocations memoires */
    00551   /* table des coordonnees
    00552      profil : (dimension * nombre de noeuds ) */
    00553   coo = (med_float*) malloc(sizeof(med_float)*nnoe*edim);
    00554   EXIT_IF(coo == NULL,NULL,NULL);
    00555   /* table  des numeros, des numeros de familles des noeuds
    00556      profil : (nombre de noeuds) */
    00557   numnoe = (med_int*) malloc(sizeof(med_int)*nnoe);
    00558   EXIT_IF(numnoe == NULL,NULL,NULL);
    00559   nufano = (med_int*) malloc(sizeof(med_int)*nnoe);
    00560   EXIT_IF(nufano == NULL,NULL,NULL);
    00561   /* table des noms des noeuds
    00562      profil : (nnoe*MED_SNAME_SIZE+1) */
    00563   nomnoe = (char*) malloc(MED_SNAME_SIZE*nnoe+1);
    00564   EXIT_IF(nomnoe == NULL,NULL,NULL);
    00565
    00566   /* lecture des noeuds :
    00567      - coordonnees
    00568      - noms (optionnel dans un fichier MED)
    00569      - numeros (optionnel dans un fichier MED)
    00570      - numeros des familles */
    00571   ret = MEDmeshNodeRd(fid,nommaa,numdt,numit, mode_coo, coo,
    00572                       &inonoe,nomnoe,&inunoe,numnoe,&ifano,nufano);
    00573
    00574
    00575   EXIT_IF(ret < 0,"lors de la lecture des noeuds du maillage \n",NULL);
    00576
    00577   /* affichage des resultats */
    00578   fprintf(stdout,"\n(************************)\n");
    00579   fprintf(stdout,"(* NOEUDS DU MAILLAGE : *)\n");
    00580   fprintf(stdout,"(************************)\n");
    00581   fprintf(stdout,"- Type de repere des coordonnees : %d \n",*rep);
    00582   fprintf(stdout,"- Nom des coordonnees : \n");
    00583   for (i=0;i<edim;i++) {
    00584     strncpy(str,nomcoo+i*MED_SNAME_SIZE,MED_SNAME_SIZE);
    00585     str[MED_SNAME_SIZE] = '\0';
    00586     fprintf(stdout," %s ",str);
    00587   }
    00588   fprintf(stdout,"\n- Unites des coordonnees : \n");
    00589   for (i=0;i<edim;i++) {
    00590     strncpy(str,unicoo+i*MED_SNAME_SIZE,MED_SNAME_SIZE);
    00591     str[MED_SNAME_SIZE] = '\0';
    00592     fprintf(stdout," %s ",str);
    00593   }
    00594   if (!structure) {
    00595   fprintf(stdout,"\n- Coordonnees des noeuds : \n");
    00596   for (i=0;i<nnoe*edim;i++) {
    00597     if (mode_coo == MED_FULL_INTERLACE && !(i % edim))
    00598       fprintf(stdout,"\n [ %5d ] : ", (i/edim + 1) );
    00599     if (mode_coo == MED_NO_INTERLACE && ! (i % nnoe))
    00600       fprintf(stdout,"\n\n ");
    00601     fprintf(stdout," %-+9.6f ",*(coo+i));
    00602   }
    00603
    00604   if (inonoe) {
    00605     fprintf(stdout,"\n- Noms des noeuds : \n");
    00606     for (i=0;i<nnoe;i++) {
    00607       strncpy(str,nomnoe+i*MED_SNAME_SIZE,MED_SNAME_SIZE);
    00608       str[MED_SNAME_SIZE] = '\0';
    00609       fprintf(stdout," %s ",str);
    00610     }
    00611   }
    00612   if (inunoe) {
    00613     fprintf(stdout,"\n- Numeros des noeuds : \n");
    00614     for (i=0;i<nnoe;i++)
    00615       fprintf(stdout," %d ",*(numnoe+i));
    00616   }
    00617
    00618   fprintf(stdout,"\n- Numeros des familles des noeuds : \n");
    00619   for (i=0;i<nnoe;i++) {
    00620     if (ifano)
    00621       fprintf(stdout," %d ",*(nufano+i));
    00622     else
    00623       fprintf(stdout," %d ",0);
    00624   }
    00625   fprintf(stdout,"\n");
    00626   }
    00627
    00628
    00629   /* liberation memoire */
    00630   free(coo);
    00631   free(nomnoe);
    00632   free(numnoe);
    00633   free(nufano);
    00634
    00635   return;
    00636 }
    00637
    00638
    00639 med_int lecture_nombre_mailles_standards(const med_idt fid,
    00640                                          const char * const nommaa,
    00641                                          const med_int numdt,
    00642                                          const med_int numit,
    00643                                          const med_geometry_type typ_geo,
    00644                                          const med_connectivity_mode typ_con,
    00645                                          const int indice)
    00646 {
    00647
    00648   med_bool chgt=MED_FALSE,trsf=MED_FALSE;
    00649
    00650   med_int nmailles = MEDmeshnEntity(fid,nommaa,numdt,numit,
    00651                                     MED_CELL,typ_geo,
    00652                                     MED_CONNECTIVITY,typ_con,&chgt,&trsf);
    00653   EXIT_IF(nmailles < 0," lors de la lecture du nombre de mailles",NULL);
    00654
    00655   if ( (indice < (MED_N_CELL_GEO_FIXED_CON-5) ) ||
    00656        (indice >= (MED_N_CELL_GEO_FIXED_CON-5) && (nmailles > 0) ) )
    00657        fprintf (stdout,"- Nombre de mailles de type %s : %d \n",nommai[indice],
    00658                 nmailles);
    00659
    00660   return nmailles;
    00661 }
    00662
    00663 void lecture_mailles_standards(const med_idt fid,
    00664                                const char *nommaa,
    00665                                const med_int numdt,
    00666                                const med_int numit,
    00667                                const med_int mdim,
    00668                                const med_int * const nmailles,
    00669                                const med_switch_mode mode_coo,
    00670                                const med_connectivity_mode typ_con)
    00671 {
    00672   med_int  taille;
    00673   med_int *connectivite;
    00674   char    *nomele;
    00675   med_int *numele;
    00676   med_int *nufael;
    00677   med_bool       inoele=MED_FALSE, inuele=MED_FALSE, inufael=MED_FALSE;
    00678   med_geometry_type typgeo;
    00679   med_int entdim;
    00680   med_int nnodes;
    00681   med_int nndes;
    00682   med_int i,j;
    00683   med_err ret = 0;
    00684   char str[MED_SNAME_SIZE+1];
    00685
    00686   fprintf(stdout,"\n(**************************)\n");
    00687   fprintf(stdout,"(* ELEMENTS DU MAILLAGE : *)\n");
    00688   fprintf(stdout,"(**************************)");
    00689
    00690   /* Lecture des connectivites, noms, numeros des mailles */
    00691   for (i=0;i<MED_N_CELL_GEO_FIXED_CON;i++)
    00692     if (nmailles[i] > 0) {
    00693
    00694       ret=_MEDgetGeometricParameter(MED_CELL, typmai[i],&entdim,&nnodes,&nndes);
    00695       EXIT_IF(ret < 0,"lors de la lecture des caractéristiques des mailles",NULL);
    00696
    00697       switch(typ_con) {
    00698       case MED_NODAL :
    00699         taille = nnodes;
    00700         break;
    00701
    00702       case MED_DESCENDING :
    00703         taille = nndes;
    00704         break;
    00705
    00706       default :
    00707         ret = -1;
    00708       }
    00709
    00710       /* allocation memoire */
    00711       connectivite = (med_int*) malloc(sizeof(med_int)*taille*nmailles[i]);
    00712       EXIT_IF(connectivite == NULL,NULL,NULL);
    00713       nomele = (char*) malloc(sizeof(char)*MED_SNAME_SIZE*nmailles[i]+1);
    00714       EXIT_IF(nomele == NULL,NULL,NULL);
    00715       numele = (med_int*) malloc(sizeof(med_int)*nmailles[i]);
    00716       EXIT_IF(numele == NULL,NULL,NULL);
    00717       nufael = (med_int*) malloc(sizeof(med_int)*nmailles[i]);
    00718       EXIT_IF(nufael == NULL,NULL,NULL);
    00719
    00720       /* lecture des données */
    00721       ret = MEDmeshElementRd( fid,nommaa,numdt,numit,MED_CELL,typmai[i],
    00722                               typ_con, mode_coo, connectivite,
    00723                               &inoele,nomele,&inuele,numele,&inufael,nufael );
    00724
    00725       EXIT_IF(ret < 0,"lors de la lecture des mailles",NULL);
    00726
    00727       if (!structure) {
    00728       /* affichage des resultats */
    00729       fprintf(stdout,"\n\n- Mailles de type %s : ", nommai[i]);
    00730       fprintf(stdout,"\n  - Connectivité : \n");
    00731       for (j=0;j<nmailles[i]*taille;j++) {
    00732             if (mode_coo == MED_FULL_INTERLACE && !(j % taille))
    00733               fprintf(stdout,"\n [ %5d ] : ", (j/taille +1) );
    00734             if (mode_coo == MED_NO_INTERLACE && !(j % nmailles[i]))
    00735               fprintf(stdout,"\n");
    00736             fprintf(stdout," %9d ",*(connectivite+j));
    00737       }
    00738
    00739       if (inoele) {
    00740         fprintf(stdout,"\n  - Noms : \n");
    00741         for (j=0;j<nmailles[i];j++) {
    00742           strncpy(str,nomele+j*MED_SNAME_SIZE,MED_SNAME_SIZE);
    00743           str[MED_SNAME_SIZE] = '\0';
    00744           fprintf(stdout," %s ",str);
    00745         }
    00746       }
    00747       if (inuele) {
    00748         fprintf(stdout,"\n  - Numeros :\n");
    00749         for (j=0;j<nmailles[i];j++)
    00750           fprintf(stdout," %d ",*(numele+j));
    00751       }
    00752       fprintf(stdout,"\n  - Numéros de familles : \n");
    00753       for (j=0;j<nmailles[i];j++)
    00754         if (inufael)
    00755           fprintf(stdout," %d ",*(nufael+j));
    00756         else
    00757           fprintf(stdout," %d ",0);
    00758           }
    00759
    00760       /* liberation memoire */
    00761       free(connectivite);
    00762       free(nomele);
    00763       free(numele);
    00764       free(nufael);
    00765     }
    00766
    00767   return;
    00768 }
    00769
    00770
    00771 med_int lecture_nombre_mailles_polygones(const med_idt fid,
    00772                                          const char * const nommaa,
    00773                                          const med_int numdt,
    00774                                          const med_int numit,
    00775                                          const med_connectivity_mode typ_con)
    00776 {
    00777
    00778   med_bool chgt=MED_FALSE,trsf=MED_FALSE;
    00779
    00780   med_int nmpolygones = MEDmeshnEntity(fid,nommaa,numdt,numit,
    00781                                     MED_CELL,MED_POLYGON,
    00782                                     MED_INDEX_NODE,typ_con,&chgt,&trsf);
    00783
    00784   EXIT_IF(nmpolygones < 0,"lors de la lecture du nombre de mailles polygone\n",
    00785           NULL);
    00786   if (nmpolygones > 0 ) nmpolygones--; else nmpolygones=0;
    00787   fprintf(stdout,"- Nombre de mailles de type MED_POLYGONE : %d \n",
    00788           nmpolygones);
    00789
    00790   return nmpolygones;
    00791 }
    00792
    00793 void lecture_mailles_polygones(const med_idt fid,
    00794                                const char * const nommaa,
    00795                                const med_int numdt,
    00796                                const med_int numit,
    00797                                const med_int nmpolygones,
    00798                                const med_switch_mode mode_coo,
    00799                                const med_connectivity_mode typ_con)
    00800 {
    00801   med_int i,j;
    00802   med_err ret = 0;
    00803   med_int taille;
    00804   med_int *connectivite;
    00805   char *nomele;
    00806   med_int *numele;
    00807   med_int *nufael;
    00808   med_int *indexp;
    00809   int ind1,ind2;
    00810   char tmp[MED_NAME_SIZE+1];
    00811   med_err ret1,ret2,ret3;
    00812   med_bool chgt=MED_FALSE,trsf=MED_FALSE;
    00813
    00814   /* lecture des mailles de type MED_POLYGONE */
    00815
    00816   /* quelle taille pour  le tableau des connectivites ? */
    00817   taille=MEDmeshnEntity(fid,nommaa,numdt,numit,
    00818                         MED_CELL,MED_POLYGON,MED_CONNECTIVITY,typ_con,
    00819                         &chgt,&trsf);
    00820   EXIT_IF(taille < 0,"lors de la lecture des parametres des mailles polygones",
    00821           NULL);
    00822
    00823   /* allocation memoire */
    00824   indexp = (med_int *) malloc(sizeof(med_int)*(nmpolygones+1));
    00825   EXIT_IF(indexp == NULL,NULL,NULL);
    00826   connectivite = (med_int *) malloc(sizeof(med_int)*taille);
    00827   EXIT_IF(connectivite == NULL,NULL,NULL);
    00828   numele = (med_int *) malloc(sizeof(med_int)*nmpolygones);
    00829   EXIT_IF(numele == NULL,NULL,NULL);
    00830   nufael = (med_int *) malloc(sizeof(med_int)*nmpolygones);
    00831   EXIT_IF(nufael == NULL,NULL,NULL);
    00832   nomele = (char *) malloc(sizeof(char)*MED_SNAME_SIZE*nmpolygones+1);
    00833   EXIT_IF(nomele == NULL,NULL,NULL);
    00834
    00835   /* lecture de la connectivite des mailles polygones */
    00836   ret = MEDmeshPolygonRd(fid,nommaa,numdt,numit,MED_CELL,typ_con,
    00837                          indexp,connectivite);
    00838
    00839   EXIT_IF(ret < 0,"lors de la lecture des connectivites des mailles polygones",
    00840           NULL);
    00841
    00842   /* lecture noms */
    00843   ret1 = MEDmeshEntityNameRd(fid,nommaa,numdt,numit,
    00844                              MED_CELL,MED_POLYGON, nomele);
    00845
    00846   /* lecture des numeros */
    00847   ret2 = (med_int) MEDmeshEntityNumberRd(fid,nommaa,numdt,numit,
    00848                                          MED_CELL, MED_POLYGON, numele);
    00849
    00850   /* lecture des numeros de familles */
    00851   ret3 = MEDmeshEntityFamilyNumberRd(fid, nommaa, MED_NO_DT, MED_NO_IT,
    00852                                      MED_CELL, MED_POLYGON, nufael);
    00853
    00854   if (!structure) {
    00855   /* affichage des resultats */
    00856   fprintf(stdout,"\n\n- Mailles de type MED_POLYGONE : ");
    00857     for (i=0;i<nmpolygones;i++) {
    00858       fprintf(stdout,"\n >> Maille MED_POLYGONE %d : \n",i+1);
    00859       fprintf(stdout,"\n  - Connectivité : ");
    00860       ind1 = *(indexp+i)-1;
    00861       ind2 = *(indexp+i+1)-1;
    00862       for (j=ind1;j<ind2;j++)
    00863         printf(" %d ",*(connectivite+j));
    00864       if (ret1 == 0) {
    00865         strncpy(tmp,nomele+i*MED_SNAME_SIZE,MED_SNAME_SIZE);
    00866         tmp[MED_SNAME_SIZE] = '\0';
    00867         fprintf(stdout,"\n  - Nom : %s \n",tmp);
    00868       }
    00869       if (ret2 == 0)
    00870         fprintf(stdout,"\n  - Numero : %d \n",*(numele+i));
    00871
    00872       if ( ret3 >= 0 )
    00873         fprintf(stdout,"\n  - Numéro de famille : %d \n",*(nufael+i));
    00874       else
    00875         fprintf(stdout,"\n  - Numéro de famille : %d \n",0);
    00876     }
    00877   }
    00878
    00879     /* on libere la memoire */
    00880     free(indexp);
    00881     free(connectivite);
    00882     free(numele);
    00883     free(nufael);
    00884     free(nomele);
    00885
    00886     return;
    00887 }
    00888
    00889
    00890 med_int lecture_nombre_mailles_polyedres(const med_idt fid,
    00891                                          const char * const nommaa,
    00892                                          const med_int numdt,
    00893                                          const med_int numit,
    00894                                          const med_connectivity_mode typ_con)
    00895 {
    00896   med_bool chgt=MED_FALSE,trsf=MED_FALSE;
    00897
    00898   med_int npolyedres = MEDmeshnEntity(fid,nommaa,numdt,numit,
    00899                                     MED_CELL,MED_POLYHEDRON,
    00900                                     MED_INDEX_FACE,typ_con,&chgt,&trsf);
    00901
    00902   EXIT_IF(npolyedres < 0,"lors de la lecture du nombre de mailles polyedre \n",
    00903           NULL);
    00904   if ( npolyedres > 0 ) npolyedres--; else npolyedres=0;
    00905   fprintf(stdout,"- Nombre de mailles de type MED_POLYEDRE : %d \n",
    00906           npolyedres);
    00907
    00908   return npolyedres;
    00909 }
    00910
    00911
    00912 void lecture_mailles_polyedres(const med_idt         fid,
    00913                                const char * const    nommaa,
    00914                                const med_int         numdt,
    00915                                const med_int         numit,
    00916                                const med_int         npolyedres,
    00917                                const med_switch_mode       mode_coo,
    00918                                const med_connectivity_mode typ_con)
    00919 {
    00920   med_int i,j,k;
    00921   med_err ret = 0;
    00922   med_int taille;
    00923   med_int *connectivite;
    00924   char    *nomele;
    00925   med_int *numele;
    00926   med_int *nufael;
    00927   med_int *indexf, *indexn;
    00928   int ind1,ind2;
    00929   char tmp[MED_SNAME_SIZE+1];
    00930   med_err ret1,ret2,ret3;
    00931   med_int nfa;
    00932   med_int nnoe;
    00933   med_int nindn;
    00934   med_bool chgt=MED_FALSE,trsf=MED_FALSE;
    00935
    00936
    00937   /* lecture des parametres de base */
    00938   taille = MEDmeshnEntity(fid,nommaa,numdt,numit,
    00939                           MED_CELL,MED_POLYHEDRON,MED_CONNECTIVITY,typ_con,
    00940                           &chgt,&trsf);
    00941   EXIT_IF(taille < 0,"lors de la lecture des parametres des mailles polyedres",
    00942           NULL);
    00943
    00944   nindn = MEDmeshnEntity(fid,nommaa,numdt,numit,
    00945                          MED_CELL,MED_POLYHEDRON,MED_INDEX_NODE,typ_con,
    00946                          &chgt,&trsf);
    00947   EXIT_IF(nindn < 0,"lors de la lecture des parametres des mailles polyedres",
    00948           NULL);
    00949
    00950   /* allocation memoire */
    00951   /* nindf == npolyedres+1 */
    00952   indexf = (med_int *) malloc(sizeof(med_int)*(npolyedres+1));
    00953   EXIT_IF(indexf == NULL,NULL,NULL);
    00954   indexn = (med_int *) malloc(sizeof(med_int)*nindn);
    00955   EXIT_IF(indexn == NULL,NULL,NULL);
    00956   connectivite  = (med_int *) malloc(sizeof(med_int)*taille);
    00957   EXIT_IF(connectivite == NULL,NULL,NULL);
    00958   numele = (med_int *) malloc(sizeof(med_int)*npolyedres);
    00959   EXIT_IF(numele == NULL,NULL,NULL);
    00960   nufael = (med_int *) malloc(sizeof(med_int)*npolyedres);
    00961   EXIT_IF(nufael == NULL,NULL,NULL);
    00962   nomele = (char *) malloc(sizeof(char)*MED_SNAME_SIZE*npolyedres+1);
    00963   EXIT_IF(nomele == NULL,NULL,NULL);
    00964
    00965   ret = MEDmeshPolyhedronRd(fid,nommaa,numdt,numit,MED_CELL,typ_con,
    00966                             indexf,indexn,connectivite);
    00967   EXIT_IF(ret < 0,
    00968           "lors de la lecture de la connectivite des mailles polyedres",
    00969           NULL);
    00970
    00971   /* lecture des noms */
    00972   ret1 = MEDmeshEntityNameRd(fid,nommaa,numdt,numit,MED_CELL,MED_POLYHEDRON,nomele);
    00973
    00974   /* lecture des numeros */
    00975   ret2 = MEDmeshEntityNumberRd(fid,nommaa,numdt,numit,MED_CELL,MED_POLYHEDRON,numele);
    00976
    00977   /* lecture des numeros de familles */
    00978   ret3 = MEDmeshEntityFamilyNumberRd(fid,nommaa,numdt,numit,MED_CELL,MED_POLYHEDRON,nufael);
    00979
    00980   if (!structure) {
    00981   /* affichage des resultats */
    00982   fprintf(stdout,"\n\n- Mailles de type MED_POLYEDRE : ");
    00983   for (i=0;i<npolyedres;i++) {
    00984     fprintf(stdout,"\n >> Maille MED_POLYEDRE %d : \n",i+1);
    00985     fprintf(stdout,"\n  - Connectivité : \n");
    00986     nfa  = *(indexf+i+1) - *(indexf+i);
    00987     /* ind1 = indice dans "faces" pour acceder aux numeros des faces */
    00988     ind1 = *(indexf+i) - 1;
    00989     for (j=0;j<nfa;j++) {
    00990       if (typ_con == MED_NODAL) {
    00991         /* ind2 = indice dans "connectivite"
    00992            pour acceder au premier noeud de la face */
    00993         ind2 = *(indexn+ind1+j) - 1;
    00994         nnoe = *(indexn+ind1+j+1) - *(indexn+ind1+j);
    00995         fprintf(stdout,"   - Face %d : [ ", j+1);
    00996         for (k=0;k<nnoe;k++)
    00997           printf(" %d ",*(connectivite+ind2+k));
    00998         printf(" ] \n");
    00999       }
    01000       else {
    01001         nfa  = *(indexf+i+1) - *(indexf+i);
    01002         /* ind1 = indice dans "connectivite"
    01003            pour acceder aux numeros des faces */
    01004         ind1 = *(indexf+i) - 1;
    01005         for (j=0;j<nfa;j++)
    01006           fprintf(stdout,"   - Face %d de numero : %d et de type %d \n", j+1,
    01007                   *(connectivite+ind1+j),*(indexn+ind1+j));
    01008       }
    01009     }
    01010     if (ret1 == 0) {
    01011       strncpy(tmp,nomele+i*MED_SNAME_SIZE,MED_SNAME_SIZE);
    01012       tmp[MED_SNAME_SIZE] = '\0';
    01013       fprintf(stdout,"\n  - Nom : %s \n",tmp);
    01014     }
    01015     if (ret2 == 0)
    01016       fprintf(stdout,"\n  - Numero : %d \n",*(numele+i));
    01017     if (ret3 >= 0)
    01018       fprintf(stdout,"\n  - Numéro de famille : %d \n",*(nufael+i));
    01019     else
    01020       fprintf(stdout,"\n  - Numéro de famille : %d \n",0);
    01021
    01022   }
    01023   }
    01024
    01025   /* on libere la memoire */
    01026   free(indexf);
    01027   free(indexn);
    01028   free(connectivite);
    01029   free(numele);
    01030   free(nufael);
    01031   free(nomele);
    01032
    01033   return;
    01034 }
    01035
    01036 med_int lecture_nombre_faces_standards(const med_idt fid,
    01037                                        const char * const nommaa,
    01038                                        const med_int numdt,
    01039                                        const med_int numit,
    01040                                        const med_geometry_type typ_geo,
    01041                                        const med_int indice
    01042                                        )
    01043 {
    01044
    01045   med_bool chgt=MED_FALSE,trsf=MED_FALSE;
    01046
    01047   med_int nfaces = MEDmeshnEntity(fid,nommaa,numdt,numit,
    01048                                     MED_DESCENDING_FACE,typ_geo,
    01049                                     MED_CONNECTIVITY,MED_DESCENDING,&chgt,&trsf);
    01050   EXIT_IF(nfaces < 0,"lors de la lecture du nombre de faces",NULL);
    01051
    01052   if ( (indice < (MED_N_FACE_GEO_FIXED_CON-2) ) ||
    01053        (indice >= (MED_N_FACE_GEO_FIXED_CON-2) && (nfaces > 0) ) )
    01054     fprintf (stdout,"- Nombre de faces de type %s : %d \n",
    01055              nomfac[indice],nfaces);
    01056
    01057   return nfaces;
    01058 }
    01059
    01060 void lecture_faces_standard(const med_idt fid,
    01061                             const char * const nommaa,
    01062                             const med_int numdt,
    01063                             const med_int numit,
    01064                             const med_int mdim,
    01065                             const med_int *const nfaces,
    01066                             const med_switch_mode mode_coo)
    01067 {
    01068   med_int taille;
    01069   med_int *connectivite;
    01070   char *nomele;
    01071   med_int *numele;
    01072   med_int *nufael;
    01073   med_bool inoele,inuele,inufael;
    01074   med_geometry_type typgeo;
    01075   med_int i,j;
    01076   med_err ret = 0;
    01077   char str[MED_SNAME_SIZE+1];
    01078   med_int entdim;
    01079   med_int nnodes;
    01080
    01081   for (i=0;i<MED_N_FACE_GEO_FIXED_CON;i++)
    01082     if (nfaces[i] > 0 ) {
    01083
    01084       /*  taille de la description : nombre d'aretes */
    01085         ret=_MEDgetGeometricParameter(MED_DESCENDING_FACE, typfac[i],&entdim,&nnodes,&taille);
    01086       EXIT_IF(ret < 0,"lors de la lecture des caractéristiques des mailles",NULL);
    01087
    01088       /* allocation memoire */
    01089       connectivite = (med_int*)malloc(sizeof(med_int)*taille*nfaces[i]);
    01090       EXIT_IF(connectivite == NULL,NULL,NULL);
    01091       nomele = (char*)malloc(sizeof(char)*MED_SNAME_SIZE*nfaces[i]+1);
    01092       EXIT_IF(nomele == NULL,NULL,NULL);
    01093       numele = (med_int*)malloc(sizeof(med_int)*nfaces[i]);
    01094       EXIT_IF(numele == NULL,NULL,NULL);
    01095       nufael = (med_int*)malloc(sizeof(med_int)*nfaces[i]);
    01096       EXIT_IF(nufael == NULL,NULL,NULL);
    01097
    01098       /* lecture des données */
    01099      ret = MEDmeshElementRd( fid,nommaa,numdt,numit,MED_DESCENDING_FACE,typmai[i],
    01100                               MED_DESCENDING, mode_coo, connectivite,
    01101                               &inoele,nomele,&inuele,numele,&inufael,nufael );
    01102       EXIT_IF(ret < 0,"lors de la lecture des faces",NULL);
    01103
    01104       if (!structure) {
    01105       /* affichage des resultats */
    01106       fprintf(stdout,"\n- Faces de type %s : ", nomfac[i]);
    01107       fprintf(stdout,"\n  - Connectivité : \n");
    01108       for (j=0;j<nfaces[i]*taille;j++) {
    01109             if (mode_coo == MED_FULL_INTERLACE && !(j % taille))
    01110               fprintf(stdout,"\n [ %5d ] : ", (j/taille+1) );
    01111             if (mode_coo == MED_NO_INTERLACE && !(j % nfaces[i]))
    01112               fprintf(stdout,"\n");
    01113             fprintf(stdout," %9d ",*(connectivite+j));
    01114           }
    01115
    01116       if (inoele) {
    01117         fprintf(stdout,"\n  - Noms : \n");
    01118         for (j=0;j<nfaces[i];j++) {
    01119           strncpy(str,nomele+j*MED_SNAME_SIZE,MED_SNAME_SIZE);
    01120           str[MED_SNAME_SIZE] = '\0';
    01121           fprintf(stdout," %s ",str);
    01122         }
    01123       }
    01124       if (inuele) {
    01125         fprintf(stdout,"\n  - Numeros :\n");
    01126         for (j=0;j<nfaces[i];j++)
    01127           fprintf(stdout," %d ",*(numele+j));
    01128       }
    01129       fprintf(stdout,"\n  - Numéros de familles : \n");
    01130       for (j=0;j<nfaces[i];j++)
    01131         if ( inufael )
    01132           fprintf(stdout," %d ",*(nufael+j));
    01133         else
    01134           fprintf(stdout," %d ",0);
    01135           }
    01136
    01137       /* liberation memoire */
    01138       free(connectivite);
    01139       free(nomele);
    01140       free(numele);
    01141       free(nufael);
    01142     }
    01143
    01144   return;
    01145 }
    01146
    01147 med_int lecture_nombre_faces_polygones(const med_idt fid,
    01148                                        const char * const nommaa,
    01149                                        const med_int numdt,
    01150                                        const med_int numit)
    01151 {
    01152
    01153   med_bool chgt=MED_FALSE,trsf=MED_FALSE;
    01154
    01155   med_int nfpolygones = MEDmeshnEntity(fid,nommaa,numdt,numit,
    01156                                        MED_CELL,MED_POLYGON,
    01157                                        MED_INDEX_NODE,MED_DESCENDING,&chgt,&trsf);
    01158
    01159   EXIT_IF(nfpolygones < 0,"lors de la lecture du nombre de faces polygone \n",
    01160           NULL);
    01161   nfpolygones--;
    01162   fprintf(stdout,"- Nombre de faces de type MED_POLYGONE : %d \n",
    01163           nfpolygones);
    01164
    01165   return nfpolygones;
    01166 }
    01167
    01168 void lecture_faces_polygones(const med_idt fid,
    01169                              const char * const nommaa,
    01170                              const med_int numdt,
    01171                              const med_int numit,
    01172                              const med_int nfpolygones,
    01173                              const med_switch_mode mode_coo)
    01174 {
    01175   med_int i,j;
    01176   med_err ret = 0;
    01177   char *nomele;
    01178   med_int *numele;
    01179   med_int *nufael;
    01180   med_int *connectivite;
    01181   med_int taille;
    01182   med_int *indexp;
    01183   int ind1,ind2;
    01184   char tmp[MED_NAME_SIZE+1];
    01185   med_err ret1,ret2,ret3;
    01186   med_bool chgt=MED_FALSE,trsf=MED_FALSE;
    01187
    01188   /* quelle taille pour  le tableau des connectivites ? */
    01189   taille=MEDmeshnEntity(fid,nommaa,numdt,numit,
    01190                         MED_DESCENDING_FACE,MED_POLYGON,MED_CONNECTIVITY,MED_DESCENDING,
    01191                         &chgt,&trsf);
    01192   EXIT_IF(taille < 0,"lors de la lecture des parametres des faces polygones",
    01193             NULL);
    01194
    01195   /* allocation memoire */
    01196   indexp = (med_int *) malloc(sizeof(med_int)*(nfpolygones+1));
    01197   EXIT_IF(indexp == NULL,NULL,NULL);
    01198   connectivite = (med_int *) malloc(sizeof(med_int)*taille);
    01199   EXIT_IF(connectivite == NULL,NULL,NULL);
    01200   numele = (med_int *) malloc(sizeof(med_int)*nfpolygones);
    01201   EXIT_IF(numele == NULL,NULL,NULL);
    01202   nufael = (med_int *) malloc(sizeof(med_int)*nfpolygones);
    01203   EXIT_IF(nufael == NULL,NULL,NULL);
    01204   nomele = (char *) malloc(sizeof(char)*MED_SNAME_SIZE*nfpolygones+1);
    01205   EXIT_IF(nomele == NULL,NULL,NULL);
    01206
    01207   /* lecture de la connectivite des faces polygones */
    01208   ret = MEDmeshPolygonRd(fid,nommaa,numdt,numit,MED_DESCENDING_FACE,MED_DESCENDING,
    01209                          indexp,connectivite);
    01210   EXIT_IF(ret < 0,"lors de la lecture des connectivites des faces polygones",
    01211           NULL);
    01212
    01213   /* lecture noms */
    01214   ret1 = MEDmeshEntityNameRd(fid,nommaa,numdt,numit,
    01215                              MED_DESCENDING_FACE,MED_POLYGON, nomele);
    01216
    01217   /* lecture des numeros */
    01218   ret2 = (med_int) MEDmeshEntityNumberRd(fid,nommaa,numdt,numit,
    01219                                          MED_DESCENDING_FACE, MED_POLYGON, numele);
    01220
    01221   /* lecture des numeros de familles */
    01222   ret3 = MEDmeshEntityFamilyNumberRd(fid, nommaa, MED_NO_DT, MED_NO_IT,
    01223                                      MED_DESCENDING_FACE, MED_POLYGON, nufael);
    01224
    01225   if (!structure) {
    01226   /* affichage des resultats */
    01227   fprintf(stdout,"\n\n- Faces de type MED_POLYGONE : ");
    01228   for (i=0;i<nfpolygones;i++) {
    01229     fprintf(stdout,"\n >> Face MED_POLYGONE %d : \n",i+1);
    01230     fprintf(stdout,"\n  - Connectivité : ");
    01231     ind1 = *(indexp+i)-1;
    01232     ind2 = *(indexp+i+1)-1;
    01233     for (j=ind1;j<ind2;j++)
    01234       fprintf(stdout," %d ",*(connectivite+j));
    01235     if (ret1 == 0) {
    01236       strncpy(tmp,nomele+j*MED_SNAME_SIZE,MED_SNAME_SIZE);
    01237       tmp[MED_SNAME_SIZE] = '\0';
    01238       fprintf(stdout,"\n  - Nom : %s \n",tmp);
    01239     }
    01240     if (ret2 == 0)
    01241       fprintf(stdout,"\n  - Numero : %d \n",*(numele+j));
    01242     if ( ret3 > 0 )
    01243       fprintf(stdout,"\n  - Numéro de famille : %d \n",*(nufael+i));
    01244     else
    01245       fprintf(stdout,"\n  - Numéro de famille : %d \n",0);
    01246   }
    01247   }
    01248
    01249   /* on libere la memoire */
    01250   free(indexp);
    01251   free(connectivite);
    01252   free(numele);
    01253   free(nufael);
    01254   free(nomele);
    01255
    01256   return;
    01257 }
    01258
    01259
    01260 med_int lecture_nombre_aretes_standards(const med_idt fid,
    01261                                         const char *const  nommaa,
    01262                                         const med_int numdt,
    01263                                         const med_int numit,
    01264                                         const med_geometry_type typ_geo,
    01265                                         const med_int indice)
    01266 {
    01267
    01268   med_bool chgt=MED_FALSE,trsf=MED_FALSE;
    01269
    01270   med_int naretes = MEDmeshnEntity(fid,nommaa,numdt,numit,
    01271                                    MED_DESCENDING_EDGE, typ_geo,
    01272                                    MED_CONNECTIVITY,MED_DESCENDING,&chgt,&trsf);
    01273   EXIT_IF(naretes < 0,"lors de la lecture du nombre d'aretes",NULL);
    01274   if ( (indice < (MED_N_EDGE_GEO_FIXED_CON-1) ) ||
    01275        (indice >= (MED_N_EDGE_GEO_FIXED_CON-1) && (naretes > 0) ) )
    01276
    01277   fprintf (stdout,
    01278            "- Nombre d'aretes de type %s : %d \n",nomare[indice],naretes);
    01279
    01280   return naretes;
    01281 }
    01282
    01283 void lecture_aretes_standards(const med_idt fid,
    01284                               const char * const nommaa,
    01285                               const med_int numdt,
    01286                               const med_int numit,
    01287                               const med_int mdim,
    01288                               const med_int * const naretes,
    01289                               const med_switch_mode mode_coo)
    01290 {
    01291   med_int taille;
    01292   med_int *connectivite;
    01293   char    *nomele;
    01294   med_int *numele;
    01295   med_int *nufael;
    01296   med_bool inoele,inuele,inufael;
    01297   med_geometry_type typgeo;
    01298   med_int i,j;
    01299   med_err ret = 0;
    01300   char str[MED_SNAME_SIZE+1];
    01301   med_int entdim;
    01302   med_int nnodes;
    01303
    01304   for (i=0;i<MED_N_EDGE_GEO_FIXED_CON;i++)
    01305     if (naretes[i] > 0) {
    01306
    01307      ret=_MEDgetGeometricParameter(MED_DESCENDING_EDGE, typare[i],&entdim,&nnodes,&taille);
    01308       EXIT_IF(ret < 0,"lors de la lecture des caractéristiques des mailles",NULL);
    01309
    01310       /* allocation memoire */
    01311       connectivite = (med_int*)malloc(sizeof(med_int)*taille*naretes[i]);
    01312       EXIT_IF(connectivite == NULL,NULL,NULL);
    01313       nomele = (char*)malloc(sizeof(char)*MED_SNAME_SIZE*naretes[i]+1);
    01314       EXIT_IF(nomele == NULL,NULL,NULL);
    01315       numele = (med_int*)malloc(sizeof(med_int)*naretes[i]);
    01316       EXIT_IF(numele == NULL,NULL,NULL);
    01317       nufael = (med_int*)malloc(sizeof(med_int)*naretes[i]);
    01318       EXIT_IF(nufael == NULL,NULL,NULL);
    01319
    01320       /* lecture des données */
    01321       ret = MEDmeshElementRd( fid,nommaa,numdt,numit,MED_DESCENDING_EDGE,typare[i],
    01322                               MED_DESCENDING, mode_coo, connectivite,
    01323                               &inoele,nomele,&inuele,numele,&inufael,nufael );
    01324       EXIT_IF(ret < 0,"lors de la lecture des aretes",
    01325               NULL);
    01326
    01327       if (!structure) {
    01328       /* affichage des resultats */
    01329       fprintf(stdout,"\n- Aretes de type %s : ", nomare[i]);
    01330       fprintf(stdout,"\n  - Connectivité : \n");
    01331       for (j=0;j<naretes[i]*taille;j++) {
    01332             if (mode_coo == MED_FULL_INTERLACE && !(j % taille))
    01333               fprintf(stdout,"\n [ %5d ] : ", (j/taille+1) );
    01334             if (mode_coo == MED_NO_INTERLACE && !(j % naretes[i]))
    01335               fprintf(stdout,"\n");
    01336             fprintf(stdout," %9d ",*(connectivite+j));
    01337           }
    01338
    01339       if (inoele) {
    01340         fprintf(stdout,"\n  - Noms : \n");
    01341         for (j=0;j<naretes[i];j++) {
    01342           strncpy(str,nomele+j*MED_SNAME_SIZE,MED_SNAME_SIZE);
    01343           str[MED_SNAME_SIZE] = '\0';
    01344           fprintf(stdout," %s ",str);
    01345         }
    01346       }
    01347       if (inuele) {
    01348         fprintf(stdout,"\n  - Numeros :\n");
    01349         for (j=0;j<naretes[i];j++)
    01350           fprintf(stdout," %d ",*(numele+j));
    01351       }
    01352       fprintf(stdout,"\n  - Numéros de familles : \n");
    01353       for (j=0;j<naretes[i];j++)
    01354         if ( inufael )
    01355           fprintf(stdout," %d ",*(nufael+j));
    01356         else
    01357           fprintf(stdout," %d ",0);
    01358           }
    01359
    01360       /* liberation memoire */
    01361       free(connectivite);
    01362       free(nomele);
    01363       free(numele);
    01364       free(nufael);
    01365     }
    01366
    01367   return;
    01368 }
    01369
    01370
    01371 /******************************************************************************
    01372  * - Nom de la fonction : lecture_maillage_non_structure
    01373  * - Description : lecture et affichage d'un maillage MED_NON_STRUCTURE.
    01374  * - Parametres :
    01375  *     - fid                       (IN) : ID du fichier MED.
    01376  *     - nommaa                    (IN) : nom du maillage a lire.
    01377  *     - mdim                      (IN) : dimension du maillage.
    01378  *     - mode_coo                  (IN) : mode de stockage en memoire :
    01379  *                                        MED_FULL_INTERLACE : entrelace |
    01380  *                                        MED_NO_INTERLACE : non entrelace.
    01381  *     - typ_con                   (IN) : mode de connectivite :
    01382  *                                        MED_DESCENDING : descendante |
    01383  *                                        MED_NODAL : nodale.
    01384  *     - lecture_en_tete_seulement (IN) : mode de lecture et d'affichage.
    01385  ******************************************************************************/
    01386
    01387 void lecture_maillage_non_structure(med_idt fid,
    01388                                     const char *nommaa,
    01389                                     const med_int numdt,
    01390                                     const med_int numit,
    01391                                     const med_int mdim,
    01392                                     const med_int edim,
    01393                                     const med_switch_mode mode_coo,
    01394                                     const med_connectivity_mode typ_con,
    01395                                     const char * const nomcoo,
    01396                                     const char * const unicoo,
    01397                                     const med_axis_type *const rep,
    01398                                     const int lecture_en_tete_seulement)
    01399 {
    01400   med_int i;
    01401   /* nombre d'objets MED : noeuds, mailles, faces, aretes , ... */
    01402   med_int nnoe;
    01403   med_int nmailles[MED_N_CELL_GEO_FIXED_CON];
    01404   med_int nfaces[MED_N_FACE_GEO_FIXED_CON];
    01405   med_int naretes[MED_N_EDGE_GEO_FIXED_CON];
    01406   /* polygones et polyedres */
    01407   med_int nmpolygones, npolyedres, nfpolygones;
    01408   /* familles */
    01409   med_int nfam;
    01410   /* equivalences */
    01411   med_int nequ;
    01412   /* joints */
    01413   med_int njnt;
    01414
    01415   /* Combien de noeuds dans le maillage ? */
    01416   nnoe = lecture_nombre_noeuds_maillage_non_structure(fid,nommaa,numdt,numit);
    01417
    01418   /*TODO : ELEMENTS DE STRUCTURE */
    01419   /*TODO : AFFICHER DT ( DTUNIT ) */
    01420   /* Combien de mailles, faces ou aretes pour chaque type geometrique ? */
    01421   for (i=0;i<MED_N_CELL_GEO_FIXED_CON;i++)
    01422     nmailles[i] = lecture_nombre_mailles_standards(fid,nommaa,numdt,numit,typmai[i],
    01423                                                    typ_con,i);
    01424
    01425   /* Combien de mailles polygones quelconques ? */
    01426   nmpolygones = lecture_nombre_mailles_polygones(fid,nommaa,numdt,numit,typ_con);
    01427
    01428   /* Combien de mailles polyedres quelconques ? */
    01429   npolyedres = lecture_nombre_mailles_polyedres(fid,nommaa,numdt,numit,typ_con);
    01430
    01431   /* Pour la connectivite descendante */
    01432   if (typ_con == MED_DESCENDING) {
    01433
    01434     /* Combien de faces : types geometriques standards ? */
    01435     for (i=0;i<MED_N_FACE_GEO_FIXED_CON;i++)
    01436       nfaces[i] = lecture_nombre_faces_standards(fid,nommaa,numdt,numit,typfac[i],i);
    01437
    01438     /* Combien de faces polygones quelconques ? */
    01439     nfpolygones = lecture_nombre_faces_polygones(fid,nommaa,numdt,numit);
    01440
    01441     /* Combien d'aretes */
    01442     for (i=0;i<MED_N_EDGE_GEO_FIXED_CON;i++)
    01443       naretes[i] = lecture_nombre_aretes_standards(fid,nommaa,numdt,numit,typare[i],i);
    01444   }
    01445
    01446   /* combien de familles ? */
    01447   nfam = lecture_nombre_famille(fid,nommaa);
    01448
    01449   /* combien d'equivalences ? */
    01450   nequ = lecture_nombre_equivalence(fid,nommaa);
    01451
    01452   /* combien de joints ? */
    01453   njnt = lecture_nombre_joint(fid,nommaa);
    01454
    01455   /* en fonction du mode de lecture, on continue ou non */
    01456   if (lecture_en_tete_seulement)
    01457     return;
    01458
    01459   /****************************************************************************
    01460   *                       LECTURE DES NOEUDS                                  *
    01461   ****************************************************************************/
    01462   lecture_noeuds_maillage_non_structure(fid,nommaa,numdt,numit,mdim,edim,nnoe,mode_coo,nomcoo,unicoo,rep);
    01463   /*ICI;_MEDobjetsOuverts(fid);*/
    01464
    01465
    01466   /****************************************************************************
    01467   *                       LECTURE DES ELEMENTS                                *
    01468   * Mailles :                                                                 *
    01469   * - Types geometriques classiques : MED_SEG2, MED_SEG3, MED_TRIA3, ...      *
    01470   * - Polygones quelconques.                                                  *
    01471   * - Polyedres quelconques.                                                  *
    01472   * Faces (connectivite descendante uniquement) :                             *
    01473   * - Types geometriques classiques.                                          *
    01474   * - Polygones quelconques.                                                  *
    01475   ****************************************************************************/
    01476
    01477   /* lecture et affichage des mailles */
    01478   lecture_mailles_standards(fid,nommaa,numdt,numit,mdim,nmailles,mode_coo,typ_con);
    01479   /*ICI;_MEDobjetsOuverts(fid);*/
    01480
    01481   if (nmpolygones > 0)
    01482     lecture_mailles_polygones(fid,nommaa,numdt,numit,nmpolygones,mode_coo,typ_con);
    01483   /*ICI;_MEDobjetsOuverts(fid);*/
    01484
    01485   if (npolyedres > 0)
    01486     lecture_mailles_polyedres(fid,nommaa,numdt,numit,npolyedres,mode_coo,typ_con);
    01487   /*ICI;_MEDobjetsOuverts(fid);*/
    01488
    01489   /* lecture et affichage des faces en connectivite descendante uniquement */
    01490   if (typ_con == MED_DESCENDING) {
    01491     lecture_faces_standard(fid,nommaa,numdt,numit,mdim,nfaces,mode_coo);
    01492     if (nfpolygones > 0)
    01493       lecture_faces_polygones(fid,nommaa,numdt,numit,nfpolygones,mode_coo);
    01494   }
    01495   /*ICI;_MEDobjetsOuverts(fid);*/
    01496
    01497   /* lecture et affichage des aretes en connectivite descendante uniquement */
    01498   if (typ_con == MED_DESCENDING)
    01499     lecture_aretes_standards(fid,nommaa,numdt,numit,mdim,naretes,mode_coo);
    01500   /*ICI;_MEDobjetsOuverts(fid);*/
    01501
    01502   /****************************************************************************
    01503   *                      LECTURE DES FAMILLES                                 *
    01504   ****************************************************************************/
    01505   lecture_famille_maillage(fid,nommaa,nfam);
    01506   /*ICI;_MEDobjetsOuverts(fid);*/
    01507
    01508
    01509   /****************************************************************************
    01510   *                       LECTURE DES EQUIVALENCES                            *
    01511   ****************************************************************************/
    01512   lecture_equivalence_maillage(fid,nommaa,nequ);
    01513   /*ICI;_MEDobjetsOuverts(fid);*/
    01514
    01515
    01516   /****************************************************************************
    01517   *                       LECTURE DES JOINTS                                  *
    01518   ****************************************************************************/
    01519   lecture_joint_maillage(fid,nommaa,njnt);
    01520   /*ICI;_MEDobjetsOuverts(fid);*/
    01521
    01522   return;
    01523 }
    01524
    01525
    01526 void lecture_caracteristiques_grille(const med_idt fid,
    01527                                      const char * const nommaa,
    01528                                      const med_int numdt,
    01529                                      const med_int numit,
    01530                                      const med_int mdim,
    01531                                      med_int *nind,
    01532                                      med_int *nnoe,
    01533                                      med_int *nmai,
    01534                                      med_grid_type *type)
    01535 {
    01536   med_err ret = 0;
    01537   med_int axe;
    01538   med_int *structure_grille;
    01539   med_data_type quoi;
    01540   med_int j;
    01541   med_bool chgt=MED_FALSE,trsf=MED_FALSE;
    01542
    01543   /* lecture de la nature du maillage structure : MED_GRILLE_CARTESIENNE ,...*/
    01544   ret = MEDmeshGridTypeRd(fid,nommaa,type);
    01545   EXIT_IF(ret < 0,"a la lecture du type d'une grille ",NULL);
    01546
    01547   switch(*type) {
    01548
    01549   case MED_CARTESIAN_GRID :
    01550   case MED_POLAR_GRID :
    01551     if (*type == MED_CARTESIAN_GRID)
    01552       fprintf(stdout,"- Type de grille : MED_GRILLE_CARTESIENNE \n");
    01553     else
    01554       fprintf(stdout,"- Type de grille : MED_GRILLE_POLAIRE \n");
    01555     for (axe=1;axe<=mdim;axe++) {
    01556       switch(axe) {
    01557
    01558       case 1:
    01559         quoi = MED_COORDINATE_AXIS1;
    01560         break;
    01561
    01562       case 2:
    01563         quoi = MED_COORDINATE_AXIS2;
    01564         break;
    01565
    01566       case 3:
    01567         quoi = MED_COORDINATE_AXIS3;
    01568         break;
    01569       }
    01570       nind[axe - 1] = MEDmeshnEntity(fid,nommaa, numdt, numit,
    01571                                      MED_NODE, MED_NONE, quoi, MED_NO_CMODE, &chgt, &trsf);
    01572
    01573       EXIT_IF(nind[axe - 1] < 0,
    01574               "lors de la lecture de la taille d'un indice d'une grille",
    01575               NULL);
    01576       *nnoe = nind[axe - 1] * (*nnoe);
    01577       *nmai = (nind[axe - 1] - 1) * (*nmai);
    01578       fprintf(stdout,
    01579               "- Taille de l'indice de l'axe %d des coordonnees : %d \n",
    01580               axe,nind[axe - 1]);
    01581     }
    01582     break;
    01583
    01584   case MED_CURVILINEAR_GRID:
    01585     fprintf(stdout,"- Type de grille : MED_GRILLE_DESTRUCTUREE \n");
    01586     *nnoe = MEDmeshnEntity(fid, nommaa, numdt, numit,
    01587                                MED_NODE, MED_NONE, MED_COORDINATE, MED_NO_CMODE, &chgt, &trsf);
    01588     EXIT_IF(*nnoe < 0,"lors de la lecture du nombre de noeuds du maillage "
    01589             ,nommaa);
    01590
    01591     /* on alloue la memoire */
    01592     structure_grille = (med_int *) malloc(sizeof(med_int)*mdim);
    01593     EXIT_IF(structure_grille == NULL,NULL,NULL);
    01594     /* on lit la structure de la grille
    01595        et on affiche le resultat */
    01596     ret = MEDmeshGridStructRd(fid,nommaa,numdt, numit, structure_grille);
    01597     EXIT_IF(ret < 0,"lors de la lecture de la structure de la grille",
    01598             NULL);
    01599     fprintf(stdout,"- Structure de la grille : [ ");
    01600     for (j=0;j<mdim;j++) {
    01601       *nmai = (*(structure_grille+j) - 1) * (*nmai);
    01602       fprintf(stdout," %d ",*(structure_grille+j));
    01603     }
    01604     fprintf(stdout," ] \n");
    01605     /* on nettoie la memoire */
    01606     free(structure_grille);
    01607     break;
    01608
    01609   MED_UNDEF_GRID_TYPE:
    01610   default:
    01611     EXIT_IF(-1,"Type de grille non reconnu.",nommaa);
    01612
    01613   }
    01614
    01615   fprintf(stdout,"- Nombre de noeuds : %d \n",*nnoe);
    01616   fprintf(stdout,"- Nombre de mailles : %d \n",*nmai);
    01617
    01618   return;
    01619 }
    01620
    01621
    01622 void lecture_noeuds_maillage_structure(const med_idt fid,
    01623                                        const char * const nommaa,
    01624                                        const med_int numdt,
    01625                                        const med_int numit,
    01626                                        const med_int mdim,
    01627                                        const med_int edim,
    01628                                        const med_int * const nind,
    01629                                        const med_int nnoe,
    01630                                        const char * const comp,
    01631                                        const char * const unit,
    01632                                        const med_grid_type type,
    01633                                        const med_switch_mode mode_coo)
    01634 {
    01635   med_err ret = 0;
    01636   med_int axe,i,j;
    01637   char str[MED_SNAME_SIZE+1];
    01638   med_float *coo     = NULL;
    01639   med_float *indices = NULL;
    01640   med_int   *nufano  = NULL;
    01641   med_int   *numnoe  = NULL;
    01642   char      *nomnoe  = NULL;
    01643   med_bool inufael=MED_FALSE;
    01644
    01645   fprintf(stdout,"\n(*************************)\n");
    01646   fprintf(stdout,"(* NOEUDS DE LA GRILLE : *)\n");
    01647   fprintf(stdout,"(*************************)\n");
    01648
    01649   switch(type) {
    01650
    01651   case MED_CARTESIAN_GRID :
    01652   case MED_POLAR_GRID :
    01653     /* on affiche les coordonnees de chacun des axes */
    01654     for (axe = 1; axe<=mdim; axe++) {
    01655       /* on alloue la memoire */
    01656       indices = (med_float *) malloc(sizeof(med_float)*nind[axe - 1]);
    01657       EXIT_IF(indices == NULL,NULL,NULL);
    01658       /* on lit le tableau des indices de coordonnees
    01659          et on affiche le resultat */
    01660       ret = MEDmeshGridIndexCoordinateRd(fid,nommaa,numdt,numit, axe,indices);
    01661       EXIT_IF(ret < 0,"lors de la lecture d'un tableau d'indice",
    01662               NULL);
    01663       fprintf(stdout,"\n - Axe %." xstr(MED_SNAME_SIZE) "s [%." xstr(MED_SNAME_SIZE) "s] : [ ",
    01664               &comp[MED_SNAME_SIZE*(axe-1)],&unit[MED_SNAME_SIZE*(axe-1)]);
    01665       for (j=0;j<nind[axe - 1];j++)
    01666         fprintf(stdout," %f ",*(indices+j));
    01667       printf(" ] \n");
    01668       /* on nettoie la memoire */
    01669       free(indices);
    01670     }
    01671     break;
    01672
    01673   case MED_CURVILINEAR_GRID:
    01674     /* on alloue la memoire */
    01675     coo = (med_float *) malloc(sizeof(med_float)*nnoe*edim);
    01676     EXIT_IF(coo == NULL,NULL,NULL);
    01677     /* on va lire les coordonnees des noeuds */
    01678     ret = MEDmeshNodeCoordinateRd(fid,nommaa,numdt,numit, MED_FULL_INTERLACE,coo);
    01679
    01680     EXIT_IF(ret < 0,"lors de la lecture des noeuds du maillage",NULL);
    01681     /* on affiche le resultat */
    01682     fprintf(stdout,"- Nom des coordonnees : \n");
    01683     for (i=0;i<edim;i++) {
    01684       strncpy(str,comp+i*MED_SNAME_SIZE,MED_SNAME_SIZE);
    01685       str[MED_SNAME_SIZE] = '\0';
    01686       fprintf(stdout," %s ",str);
    01687     }
    01688     fprintf(stdout,"\n- Unites des coordonnees : \n");
    01689     for (i=0;i<edim;i++) {
    01690       strncpy(str,unit+i*MED_SNAME_SIZE,MED_SNAME_SIZE);
    01691       str[MED_SNAME_SIZE] = '\0';
    01692       fprintf(stdout," %s ",str);
    01693     }
    01694     if (!structure) {
    01695     fprintf(stdout,"\n - Coordonnees des noeuds : [ ");
    01696     for (j=0;j<nnoe*edim;j++)
    01697       fprintf(stdout," %f ",*(coo+j));
    01698     fprintf(stdout," ] \n");
    01699     }
    01700
    01701     /* on nettoie la memoire */
    01702     free(coo);
    01703     break;
    01704
    01705   MED_UNDEF_GRID_TYPE:
    01706   default:
    01707     EXIT_IF(-1,"Type de grille non reconnu.",nommaa);
    01708
    01709   }
    01710
    01711   /* lecture et affichage des :
    01712      - numeros de familles des noeuds
    01713      - noms des noeuds (optionnel)
    01714      - numeros des noeuds (optionnel) */
    01715
    01716   /* on alloue la memoire */
    01717   numnoe = (med_int *) malloc(sizeof(med_int)*nnoe);
    01718   EXIT_IF(numnoe == NULL,NULL,NULL);
    01719   nomnoe = (char*) malloc(MED_SNAME_SIZE*nnoe+1);
    01720   EXIT_IF(nomnoe == NULL,NULL,NULL);
    01721   nufano = (med_int *) malloc(sizeof(med_int)*nnoe);
    01722   EXIT_IF(nufano == NULL,NULL,NULL);
    01723
    01724   /* on va lire les numeros de familles des noeuds */
    01725   ret = MEDmeshEntityFamilyNumberRd(fid,nommaa,numdt,numit,MED_NODE,MED_NO_GEOTYPE,nufano);
    01726   if (ret < 0) ret=0; else inufael=MED_TRUE;
    01727
    01728   EXIT_IF(ret < 0,"lors de la lecture des numeros de familles des noeuds",
    01729           NULL);
    01730   if (!structure) {
    01731   /* on affiche le resultat */
    01732   fprintf(stdout,"\n- Numeros des familles des noeuds : \n");
    01733   for (i=0;i<nnoe;i++)
    01734     if (inufael)
    01735       fprintf(stdout," %d ",*(nufano+i));
    01736     else
    01737       fprintf(stdout," %d ",0);
    01738   fprintf(stdout,"\n");
    01739   }
    01740
    01741   /* on va lire et afficher les noms des noeuds */
    01742   if (MEDmeshEntityNameRd(fid,nommaa,numdt,numit,MED_NODE,MED_NO_GEOTYPE,nomnoe) == 0) {
    01743     if (!structure) {
    01744     fprintf(stdout,"\n- Noms des noeuds : \n");
    01745     for (i=0;i<nnoe;i++) {
    01746       strncpy(str,nomnoe+i*MED_SNAME_SIZE,MED_SNAME_SIZE);
    01747       str[MED_SNAME_SIZE] = '\0';
    01748       fprintf(stdout," %s ",str);
    01749     }
    01750     }
    01751   }
    01752
    01753   /* on va lire et afficher les numeros des noeuds */
    01754   if (MEDmeshEntityNumberRd(fid,nommaa,numdt,numit,MED_NODE,MED_NO_GEOTYPE,numnoe) == 0) {
    01755     if (!structure) {
    01756     fprintf(stdout,"\n- Numeros des noeuds : \n");
    01757     for (i=0;i<nnoe;i++)
    01758       fprintf(stdout," %d ",*(numnoe+i));
    01759     }
    01760   }
    01761
    01762   /* on nettoie la memoire */
    01763   free(nufano);
    01764   free(numnoe);
    01765   free(nomnoe);
    01766
    01767   return;
    01768 }
    01769
    01770
    01771 void lecture_mailles_maillage_structure(const med_idt fid,
    01772                                         const char * const nommaa,
    01773                                         const med_int numdt,
    01774                                         const med_int numit,
    01775                                         const med_int mdim,
    01776                                         const med_int nmai)
    01777
    01778 {
    01779   med_err ret = 0;
    01780   med_int i;
    01781   med_int *nufael = NULL;
    01782   char    *nomele = NULL;
    01783   med_int *numele = NULL;
    01784   char str[MED_SNAME_SIZE+1];
    01785   /* type geometrique des elements */
    01786   med_geometry_type typgeo;
    01787
    01788   fprintf(stdout,"\n(***************************)\n");
    01789   fprintf(stdout,"(* ELEMENTS DE LA GRILLE : *)\n");
    01790   fprintf(stdout,"(***************************)\n");
    01791
    01792   /* type des mailles */
    01793   switch(mdim) {
    01794   case 0 :
    01795     typgeo = MED_POINT1;
    01796     break;
    01797   case 1 :
    01798     typgeo = MED_SEG2;
    01799     break;
    01800   case 2 :
    01801     typgeo = MED_QUAD4;
    01802     break;
    01803   default :
    01804     typgeo = MED_HEXA8;
    01805   }
    01806
    01807   /* On va lire et afficher :
    01808    * - Les numeros de familles
    01809    * - Les noms (optionnel)
    01810    * - Les numeros (optionnel)
    01811    */
    01812
    01813   /* on alloue la memoire */
    01814   numele = (med_int *) malloc(sizeof(med_int)*nmai);
    01815   EXIT_IF(numele == NULL,NULL,NULL);
    01816   nomele = (char *) malloc(sizeof(char)*MED_SNAME_SIZE*nmai+1);
    01817   EXIT_IF(nomele == NULL,NULL,NULL);
    01818   nufael = (med_int *) malloc(sizeof(med_int)*nmai);
    01819   EXIT_IF(nufael == NULL,NULL,NULL);
    01820
    01821   /* lecture des numeros de famille */
    01822   ret = MEDmeshEntityFamilyNumberRd(fid,nommaa,numdt,numit,MED_CELL,typgeo,nufael);
    01823   if (ret < 0)
    01824     for (i=0;i<nmai;i++)
    01825       *(nufael+i) = 0;
    01826
    01827   if (!structure) {
    01828   /* on affiche le resultat */
    01829   fprintf(stdout,"\n- Numeros des familles des mailles : \n");
    01830   for (i=0;i<nmai;i++)
    01831     fprintf(stdout," %d ",*(nufael+i));
    01832   fprintf(stdout,"\n");
    01833   }
    01834
    01835   /* on va lire et afficher les noms des mailles */
    01836   if (MEDmeshEntityNameRd(fid,nommaa,numdt,numit,MED_CELL,typgeo,nomele) == 0) {
    01837     if (!structure) {
    01838     fprintf(stdout,"\n  - Noms : \n");
    01839     for (i=0;i<nmai;i++) {
    01840           strncpy(str,nomele+i*MED_SNAME_SIZE,MED_SNAME_SIZE);
    01841           str[MED_SNAME_SIZE] = '\0';
    01842           fprintf(stdout," %s ",str);
    01843         }
    01844         }
    01845   }
    01846
    01847   /* on va lire et afficher les numeros des mailles */
    01848   if (MEDmeshEntityNumberRd(fid,nommaa,numdt,numit,MED_CELL,typgeo,numele) == 0) {
    01849     if (!structure) {
    01850     fprintf(stdout,"\n  - Numeros :\n");
    01851     for (i=0;i<nmai;i++)
    01852       fprintf(stdout," %d ",*(numele+i));
    01853     }
    01854   }
    01855
    01856   /* on libere la memoire */
    01857   free(nufael);
    01858   free(nomele);
    01859   free(numele);
    01860
    01861   return;
    01862 }
    01863
    01864 void lecture_maillage_structure(const med_idt fid,
    01865                                 const char * const nommaa,
    01866                                 const med_int numdt,
    01867                                 const med_int numit,
    01868                                 const med_int mdim,
    01869                                 const med_int edim,
    01870                                 const med_switch_mode mode_coo,
    01871                                 const char * const comp,
    01872                                 const char * const unit,
    01873                                 const int lecture_en_tete_seulement)
    01874 {
    01875   med_err ret = 0;
    01876   /* nombre de valeurs selon les axes du repere */
    01877   med_int nind[3];
    01878   med_int nnoe = 1;
    01879   med_int nmai = 1;
    01880   /* type de la grille */
    01881   med_grid_type type;
    01882   /* nombre de familles */
    01883   med_int nfam;
    01884   /* nombre d'equivalences */
    01885   med_int nequ;
    01886   /* nombre de joints */
    01887   med_int njnt;
    01888
    01889   /* lecture selon la nature de la grille des caracteristiques
    01890      du maillage :
    01891      - nombre de noeuds
    01892      - nombre de mailles
    01893   */
    01894   lecture_caracteristiques_grille(fid,nommaa,numdt,numit,mdim,nind,&nnoe,&nmai,&type);
    01895
    01896   /* nombre de familles */
    01897   nfam = lecture_nombre_famille(fid,nommaa);
    01898
    01899   /* nombre d'equivalences  */
    01900   nequ = lecture_nombre_equivalence(fid,nommaa);
    01901
    01902   /* combien de joints */
    01903   njnt = lecture_nombre_joint(fid,nommaa);
    01904
    01905   if (lecture_en_tete_seulement)
    01906     return ;
    01907
    01908   /****************************************************************************
    01909   *                      LECTURE DES NOEUDS                                   *
    01910   ****************************************************************************/
    01911   lecture_noeuds_maillage_structure(fid,nommaa,numdt,numit,mdim,edim,nind,nnoe,comp,unit,type,mode_coo);
    01912
    01913   /****************************************************************************
    01914   *                      LECTURE DES ELEMENTS                                 *
    01915   ****************************************************************************/
    01916   lecture_mailles_maillage_structure(fid,nommaa,numdt,numit,mdim,nmai);
    01917
    01918   /****************************************************************************
    01919   *                      LECTURE DES FAMILLES                                 *
    01920   ****************************************************************************/
    01921   lecture_famille_maillage(fid,nommaa,nfam);
    01922
    01923   /****************************************************************************
    01924   *                       LECTURE DES EQUIVALENCES                            *
    01925   ****************************************************************************/
    01926   lecture_equivalence_maillage(fid,nommaa,nequ);
    01927
    01928   /****************************************************************************
    01929   *                       LECTURE DES JOINTS                                  *
    01930   ****************************************************************************/
    01931   lecture_joint_maillage(fid,nommaa,njnt);
    01932
    01933   return ;
    01934 }
    01935
    01936 med_err getFieldsOn(const med_idt fid,
    01937                     const char * const maillage,
    01938                     const med_int mnumdt,
    01939                     const med_int mnumit,
    01940                     const char * const nomcha,
    01941                     const char * const dtunit,
    01942                     const med_field_type typcha,
    01943                     const med_int ncomp,
    01944                     const med_entity_type entite,
    01945                     const med_switch_mode stockage,
    01946                     const med_int ncstp) {
    01947
    01948   int i,j,k,l,m,n,nb_geo=0;
    01949   med_int nbpdtnor=0,pflsize,*pflval,ngauss=0,ngauss_maa_ass=0,ngroup,*vale=NULL,nval;
    01950   med_int numdt=0,numo=0,_nbofprofile;
    01951   med_int meshnumdt=0,meshnumit=0;
    01952   med_float *valr=NULL,dt=0.0;
    01953   med_err ret=0;
    01954   char pflname [MED_NAME_SIZE+1]="";
    01955   char locname [MED_NAME_SIZE+1]="";
    01956   char meshname [MED_NAME_SIZE+1]="";
    01957   char maa_ass [MED_NAME_SIZE+1]="";
    01958   char * lien = NULL;
    01959   med_bool localmesh;
    01960   med_int nmesh=0;
    01961   med_int lnsize=0;
    01962   med_geometry_type * type_geo;
    01963
    01964   const char * const * AFF;
    01965   const char * const * AFF_ENT=MED23FIELD_GET_ENTITY_TYPENAME+1;
    01966   switch (entite) {
    01967   case MED_NODE :
    01968     type_geo = MED23FIELD_GET_NODE_GEOMETRY_TYPE;
    01969     nb_geo   = MED_N_NODE_FIXED_GEO;
    01970     AFF      = MED23FIELD_GET_NODE_GEOMETRY_TYPENAME;
    01971     break;
    01972   case  MED_CELL :
    01973   case  MED_NODE_ELEMENT :
    01974     type_geo = MED23FIELD_GET_CELL_GEOMETRY_TYPE;
    01975     nb_geo   = MED_N_CELL_FIXED_GEO;
    01976     AFF      = MED23FIELD_GET_CELL_GEOMETRY_TYPENAME;
    01977     break;
    01978   case  MED_DESCENDING_FACE :
    01979     type_geo = MED23FIELD_GET_FACE_GEOMETRY_TYPE;
    01980     nb_geo   = MED_N_FACE_FIXED_GEO;
    01981     AFF      = MED23FIELD_GET_FACE_GEOMETRY_TYPENAME;
    01982     break;
    01983   case  MED_DESCENDING_EDGE :
    01984     type_geo = MED23FIELD_GET_EDGE_GEOMETRY_TYPE;
    01985     nb_geo   = MED_N_EDGE_FIXED_GEO;
    01986     AFF      = MED23FIELD_GET_EDGE_GEOMETRY_TYPENAME;
    01987     break;
    01988   }
    01989
    01990   for (k=1;k<=nb_geo;k++) {
    01991
    01992     /* Combien de (PDT,NOR) a lire */
    01993     nbpdtnor = ncstp;
    01994     if (nbpdtnor < 1 ) continue;
    01995
    01996     for (j=0;j<nbpdtnor;j++) {
    01997
    01998       if ( MEDfield23ComputingStepMeshInfo(fid,nomcha,j+1, &numdt, &numo, &dt,
    01999                                            &nmesh, maa_ass,&localmesh, &meshnumdt, &meshnumit ) <0) {
    02000         MESSAGE("Erreur a la demande d'information sur (pdt,nor) : ");
    02001         ISCRUTE(numdt); ISCRUTE(numo);ISCRUTE(nmesh);SSCRUTE(meshname);ISCRUTE_int(localmesh);
    02002         ISCRUTE(meshnumdt);ISCRUTE(meshnumit);
    02003         ret = -1; continue;
    02004       }
    02005
    02006       for (i=0;i< nmesh;++i) {
    02007
    02008         if ( (_nbofprofile = MEDfield23nProfile(fid,nomcha,numdt,numo,entite,type_geo[k],i+1,meshname,
    02009                                                 pflname,locname   ) ) < 0 ) {
    02010           MESSAGE("Erreur a la demande du nombre de profils referencés par le champ : ");
    02011           SSCRUTE(nomcha); ISCRUTE(numdt); ISCRUTE(numo);SSCRUTE(meshname);
    02012           ISCRUTE_int(entite);ISCRUTE_int(type_geo[k]);SSCRUTE(pflname);SSCRUTE(locname);
    02013           SSCRUTE(AFF_ENT[(int)entite]);SSCRUTE(AFF[k]);
    02014           ret = -1; continue;
    02015         };
    02016
    02017         for (l=0;l<_nbofprofile;l++) {
    02018
    02019           if ( (nval = MEDfield23nValueWithProfile(fid, nomcha, numdt, numo,  entite, type_geo[k],meshname,
    02020                                                    l+1,  USER_MODE, pflname,&pflsize,
    02021                                                    locname, &ngauss) ) < 0 ) {
    02022             MESSAGE("Erreur a la lecture du nombre de valeurs du champ : ");
    02023             SSCRUTE(nomcha);ISCRUTE(numdt);ISCRUTE(numo);SSCRUTE(meshname);
    02024             ISCRUTE_int(entite);ISCRUTE_int(type_geo[k]);
    02025             ISCRUTE_int(USER_MODE);
    02026             ret = -1; continue;
    02027           };
    02028           if (!strcmp(meshname,maa_ass) ) ngauss_maa_ass = ngauss;
    02029
    02030           if (_nbofprofile > 1 )
    02031             printf("\n  +Pas de Temps n."IFORMAT" (%f) [%s], n. d'ordre "IFORMAT", avec "IFORMAT" valeur(s) par entité.\n",numdt,dt,dtunit,numo,ngauss);
    02032           else {
    02033             printf("\n  +Pas de Temps n."IFORMAT" (%f) [%s], n. d'ordre "IFORMAT", avec "IFORMAT" pts de gauss sur le maillage par defaut.\n",numdt,dt,dtunit,numo,ngauss_maa_ass);
    02034             printf("\tLe maillage par defaut est : |%s|, sur un total de : %i maillages associes\n",  maa_ass, nmesh);
    02035           }
    02036
    02037           if ( (!strcmp(meshname,maillage)) && (meshnumdt == mnumdt) && (meshnumit == mnumit) ) {
    02038
    02039             if (_nbofprofile > 1 ) {
    02040               printf("\t- Il y a "IFORMAT" entités qui portent des valeurs en mode %i. Chaque entite %s\
    02041  de type geometrique %s associes au profile |%s| a "IFORMAT" valeurs associées \n",
    02042                      nval,USER_MODE,AFF_ENT[(int)entite],AFF[k],pflname,ngauss);
    02043               printf("\t- Le maillage associé est |%s|\n",meshname);
    02044             } else {
    02045               /*TODO : Rétablir un affichage en nombre d'entité et pas en nombre de valeurs */
    02046               printf("\t- Il y a %d valeurs en mode %i. Chaque entite %s\
    02047  de type geometrique %s associes au maillage |%s| a %i pts de gauss \n",
    02048                      nval*ngauss,USER_MODE,AFF_ENT[(int)entite],AFF[k],
    02049                      maa_ass,ngauss);
    02050             }
    02051
    02052             if ( (meshnumdt != MED_NO_DT) || (meshnumit != MED_NO_IT) )
    02053               printf("\t- La séquence de calcul utilisée dans le maillage associé |%s| est (numdt,numit) : ("IFORMAT","IFORMAT") \n",meshname,meshnumdt,meshnumit);
    02054
    02055             /* Le maillage reference est-il porte par un autre fichier */
    02056             if ( !localmesh ) {
    02057
    02058               if ( (lnsize=MEDlinkInfoByName(fid,maa_ass) ) < 0 )  {
    02059               MESSAGE("Erreur a la lecture de la taille du lien : ");
    02060               SSCRUTE(maa_ass);
    02061               ret = -1;
    02062             } else {
    02063               lien = (char *)malloc(lnsize*sizeof(char) + 1);
    02064               EXIT_IF(lien == NULL,NULL,NULL);
    02065
    02066               if ( MEDlinkRd(fid, maa_ass, lien) < 0 )  {
    02067                 MESSAGE("Erreur a la lecture du lien : ");
    02068                 SSCRUTE(maa_ass);SSCRUTE(lien);
    02069                 ret = -1;
    02070               } else {
    02071                 lien[lnsize] = '\0';
    02072                 printf("\tLe maillage |%s| est porte par un fichier distant |%s|\n",maa_ass,lien);
    02073               }
    02074               free(lien);
    02075               }
    02076             }
    02077
    02078             /*Lecture des valeurs du champ */
    02079             if (typcha == MED_FLOAT64) {
    02080
    02081               valr = (med_float*) calloc(ncomp*nval*ngauss,sizeof(med_float));
    02082               EXIT_IF(valr == NULL,NULL,NULL);
    02083
    02084               if (MEDfield23ValueWithProfileRd(fid, nomcha, numdt,numo, entite,type_geo[k],meshname,
    02085                                                USER_MODE, pflname, stockage,MED_ALL_CONSTITUENT,
    02086                                                (unsigned char*) valr) < 0 ) {
    02087                 MESSAGE("Erreur a la lecture des valeurs du champ : ");
    02088                 SSCRUTE(nomcha);ISCRUTE_int(entite);ISCRUTE_int(type_geo[k]);
    02089                 ISCRUTE(numdt);ISCRUTE(numo);
    02090                 ret = -1;
    02091               }
    02092             } else {
    02093
    02094               vale = (med_int*) calloc(ncomp*nval*ngauss,sizeof(med_int));
    02095               EXIT_IF(vale == NULL,NULL,NULL);
    02096
    02097               if (MEDfield23ValueWithProfileRd(fid, nomcha, numdt,numo, entite,type_geo[k],meshname,
    02098                                                USER_MODE, pflname, stockage,MED_ALL_CONSTITUENT,
    02099                                                (unsigned char*) vale) < 0 ) {
    02100                 MESSAGE("Erreur a la lecture des valeurs du champ : ");
    02101                 SSCRUTE(nomcha);ISCRUTE_int(entite);ISCRUTE_int(type_geo[k]);
    02102                 ISCRUTE(numdt);ISCRUTE(numo);
    02103                 ret = -1;
    02104               }
    02105             }
    02106
    02107             if ( strlen(locname) && (_nbofprofile > 1) )
    02108               printf("\t- Modèle de localisation des points de Gauss de nom |%s|\n",locname);
    02109
    02110             if (entite == MED_NODE_ELEMENT)
    02111               ngroup = (type_geo[k] % 100);
    02112             else
    02113               ngroup = ngauss;
    02114
    02115             switch (stockage) {
    02116
    02117             case MED_FULL_INTERLACE :
    02118               if (!structure) {
    02119                 printf("\t- Valeurs :\n\t");
    02120                 for (m=0;m<(nval*ngauss)/ngroup;m++) {
    02121                   printf("|");
    02122                   for (n=0;n<ngroup*ncomp;n++)
    02123                     if (typcha == MED_FLOAT64)
    02124                       printf(" %f ",*(valr+(m*ngroup*ncomp)+n));
    02125                     else
    02126                       printf(" "IFORMAT" ",*(vale+(m*ngroup*ncomp)+n));
    02127                 }
    02128               }
    02129               break;
    02130
    02131               /*??? Affichage en fonction du profil à traiter ???*/
    02132             case MED_NO_INTERLACE :
    02133               if (!structure) {
    02134                 printf("\t- Valeurs :\n\t");
    02135                 for (m=0;m<ncomp;m++) {
    02136                   printf("|");
    02137                   for (n=0;n<(nval*ngauss);n++)
    02138                     if (typcha == MED_FLOAT64)
    02139                       printf(" %f ",*(valr+(m*nval)+n));
    02140                     else
    02141                       printf(" "IFORMAT" ",*(vale+(m*nval)+n));
    02142                 }
    02143               }
    02144               break;
    02145             }
    02146
    02147             if (!structure) {
    02148               printf("|\n");
    02149             }
    02150
    02151             if (typcha == MED_FLOAT64) {
    02152               if ( valr ) {free(valr);valr = NULL;}}
    02153             else
    02154               if (vale) { free(vale);vale = NULL; }
    02155
    02156             /*Lecture du profil associe */
    02157             if (strcmp(pflname,MED_NO_PROFILE) == 0 ) {
    02158               printf("\t- Profil : MED_NOPFL\n");
    02159               /* TODO : Réactiver */
    02160 /*            printf("\t- Profil : MED_NO_PROFILE\n"); */
    02161             } else {
    02162               if ( (pflsize = MEDprofileSizeByName(fid,pflname)) <0 )  {
    02163                 MESSAGE("Erreur a la lecture du nombre de valeurs du profil : ");
    02164                 SSCRUTE(pflname);
    02165                 ret = -1; continue;
    02166             }
    02167
    02168               printf("\t- Profil : |%s| de taille "IFORMAT"\n",pflname,pflsize);
    02169
    02170               pflval = (med_int*) malloc(sizeof(med_int)*pflsize);
    02171               EXIT_IF(pflval == NULL,NULL,NULL);
    02172               if ( MEDprofileRd(fid,pflname,pflval) <0) {
    02173                 MESSAGE("Erreur a la lecture des valeurs du profil : ");
    02174                 SSCRUTE(pflname);
    02175                 ret = -1;
    02176               }
    02177               if (!structure) {
    02178                 printf("\t");
    02179                 for (m=0;m<pflsize;m++) printf(" "IFORMAT" ",*(pflval+m));
    02180                 printf("\n");
    02181               }
    02182               free(pflval);
    02183             }
    02184           }
    02185         }
    02186       }
    02187     }
    02188   } /* fin for sur les mailles*/
    02189
    02190   return ret;
    02191 }
    02192
    02193 /******************************************************************************
    02194  *
    02195  * - Nom de la fonction : lecture_resultats
    02196  * - Description : lecture et affichage des champs de resultats
    02197  *                 associe a un  maillage MED.
    02198  * - Parametres :
    02199  *     - fid                       (IN) : ID du fichier MED.
    02200  *     - maillage                  (IN) : nom du maillage maillage.
    02201  *     - mode_coo                  (IN) : mode de stockage en memoire :
    02202  *                                        MED_FULL_INTERLACE |
    02203  *                                        MED_NO_INTERLACE.
    02204  *     - lecture_en_tete_seulement (IN) : mode de lecture.
    02205  ******************************************************************************/
    02206
    02207 void lecture_resultats(const med_idt fid,
    02208                        const char * const    maillage,
    02209                        const med_int mnumdt,
    02210                        const med_int mnumit,
    02211                        const med_switch_mode mode_coo,
    02212                        const int lecture_en_tete_seulement)
    02213 {
    02214   med_err ret,lret;
    02215   char pflname[MED_NAME_SIZE+1]="",nomlien[MED_NAME_SIZE+1]="";
    02216   char *lien = NULL;
    02217   char *comp, *unit;
    02218   char nomcha  [MED_NAME_SIZE+1]="";
    02219   char locname [MED_NAME_SIZE+1]="";
    02220   med_int mdim,ncomp,ncha,npro,nln,pflsize,*pflval,nval,nloc,ngauss;
    02221   med_field_type typcha;
    02222   med_mesh_type type;
    02223   int t1,t2,t3;
    02224   med_geometry_type type_geo;
    02225   med_float *refcoo, *gscoo, *wg;
    02226   int i,j;
    02227
    02228   char     nommaa[MED_NAME_SIZE+1]="";
    02229   med_bool localmaa = MED_FALSE;
    02230   char     dtunit[MED_SNAME_SIZE+1]="";
    02231   med_int  nbofcstp=0;
    02232
    02233   med_int locsdim=0;
    02234   char    geointerpname       [MED_NAME_SIZE+1]="";
    02235   char    ipointstructmeshname[MED_NAME_SIZE+1]="";
    02236   med_int nsectionmeshcell = 0;
    02237   med_geometry_type sectiongeotype;
    02238
    02239   if (! lecture_en_tete_seulement) {
    02240     fprintf(stdout,"\n(************************)\n");
    02241     fprintf(stdout,"(* CHAMPS DU MAILLAGE : *)\n");
    02242     fprintf(stdout,"(************************)\n");
    02243   }
    02244
    02245   /* combien de champs dans le fichier */
    02246   ncha = MEDnField(fid);
    02247   EXIT_IF(ncha < 0,"lors de la lecture du nombre de champs",NULL);
    02248   fprintf(stdout,"- Nombre de champs : %d \n",ncha);
    02249
    02250   if (lecture_en_tete_seulement)
    02251     return;
    02252
    02253   /****************************************************************************
    02254   *                       LECTURE DES CHAMPS                                  *
    02255   ****************************************************************************/
    02256   ret = 0;
    02257
    02258   /* lecture de tous les champs  pour le maillage selectionne */
    02259   for (i =0;i<ncha;i++) {
    02260     lret = 0;
    02261     printf("\nChamp numero : |%d| \n",i+1);
    02262
    02263     /* Lecture du nombre de composantes */
    02264     if ((ncomp = MEDfieldnComponent(fid,i+1)) < 0) {
    02265       MESSAGE("Erreur à la lecture du nombre de composantes : ");
    02266       ISCRUTE(ncomp);
    02267       ret = -1; continue;
    02268     }
    02269
    02270     /* Lecture du type du champ, des noms des composantes et du nom de
    02271        l'unité*/
    02272     comp = (char*) malloc(ncomp*MED_SNAME_SIZE+1);
    02273     EXIT_IF(comp == NULL,NULL,NULL);
    02274     unit = (char*) malloc(ncomp*MED_SNAME_SIZE+1);
    02275     EXIT_IF(unit == NULL,NULL,NULL);
    02276
    02277     if ( MEDfieldInfo(fid, i+1, nomcha, nommaa, &localmaa,
    02278                      &typcha, comp, unit, dtunit, &nbofcstp) < 0 ) {
    02279       MESSAGE("Erreur à la demande d'information sur les champs : ");
    02280       ret = -1; continue;
    02281     }
    02282
    02283     printf("Nom du champ : |%s| de type |%d|\n",nomcha,typcha);
    02284     printf("Nom des composantes : |%s|\n",comp);
    02285     printf("Unites des composantes : |%s| \n",unit);
    02286     /* TODO: réactiver */
    02287 /*     if (strlen(dtunit)) */
    02288 /*       printf("Unité des dates : |%s|\n",dtunit); */
    02289 /*     if ( nbofcstp > 1 ) */
    02290 /*       printf("Nombre d'étapes de calcul : |"IFORMAT"| \n",nbofcstp); */
    02291
    02292     free(comp);
    02293     free(unit);
    02294
    02295     /* champs aux noeuds */
    02296     lret = getFieldsOn(fid, maillage, mnumdt, mnumit, nomcha, dtunit, typcha, ncomp, MED_NODE,mode_coo, nbofcstp);
    02297
    02298     /* champs sur les elements et aux points de Gauss */
    02299     if (lret == 0) lret = getFieldsOn(fid, maillage, mnumdt, mnumit , nomcha, dtunit, typcha, ncomp, MED_CELL,mode_coo, nbofcstp);
    02300     else { MESSAGE("Erreur à la lecture des champs aux noeuds "); ret = -1; continue;}
    02301
    02302     if (lret == 0) lret = getFieldsOn(fid, maillage, mnumdt, mnumit , nomcha, dtunit, typcha, ncomp, MED_DESCENDING_FACE,mode_coo, nbofcstp);
    02303     else { MESSAGE("Erreur à la lecture des champs aux mailles "); ret = -1; continue;}
    02304
    02305     if (lret == 0) lret = getFieldsOn(fid, maillage, mnumdt, mnumit , nomcha, dtunit, typcha, ncomp, MED_DESCENDING_EDGE,mode_coo, nbofcstp);
    02306     else {MESSAGE("Erreur à la lecture des champs aux faces "); ret = -1; continue;}
    02307
    02308     if (lret == 0) lret = getFieldsOn(fid, maillage, mnumdt, mnumit , nomcha, dtunit, typcha, ncomp, MED_NODE_ELEMENT,mode_coo, nbofcstp);
    02309     else {MESSAGE("Erreur a la lecture des champs aux aretes "); ret = -1; continue;}
    02310
    02311     if  (lret != 0) {MESSAGE("Erreur a la lecture des champs aux noeuds des mailles "); ret = -1;};
    02312   }
    02313
    02314
    02315   /* Interrogation des profils */
    02316   npro = MEDnProfile(fid);
    02317
    02318   printf("\nNombre de profils stockes : "IFORMAT"\n\n",npro);
    02319   for (i=1 ; i <= npro ; i++ ) {
    02320     if ( MEDprofileInfo(fid, i, pflname, &nval) < 0)  {
    02321       MESSAGE("Erreur a la demande d'information sur le profil n° : "); ISCRUTE_int(i);
    02322       ret = -1;continue;
    02323     }
    02324     printf("\t- Profil n°%i de nom |%s| et de taille "IFORMAT"\n",i,pflname,nval);
    02325     pflval = (med_int*) malloc(sizeof(med_int)*nval);
    02326     if ( MEDprofileRd(fid, pflname, pflval) < 0) {
    02327       MESSAGE("Erreur a la lecture des valeurs du profil : ");
    02328       SSCRUTE(pflname);
    02329       ret = -1;
    02330     } else {
    02331       printf("\t");
    02332       for (j=0;j<nval;j++) printf(" "IFORMAT" ",*(pflval+j));
    02333       printf("\n\n");
    02334     }
    02335     free(pflval);
    02336   }
    02337
    02338   /* Interrogation des liens */
    02339   nln = MEDnLink(fid);
    02340
    02341   printf("\nNombre de liens stockes : "IFORMAT"\n\n",nln);
    02342   for (i=1 ; i <= nln ; i++ ) {
    02343     if ( MEDlinkInfo(fid, i, nomlien, &nval) < 0)  {
    02344       MESSAGE("Erreur a la demande d'information sur le lien n° : "); ISCRUTE_int(i);
    02345       ret = -1;continue;
    02346     }
    02347     printf("\t- Lien n°%i de nom |%s| et de taille "IFORMAT"\n",i,nomlien,nval);
    02348
    02349     lien = (char * ) malloc((nval+1)*sizeof(char));
    02350     EXIT_IF(lien == NULL,NULL,NULL);
    02351
    02352     if ( MEDlinkRd(fid, nomlien, lien ) < 0 )  {
    02353       MESSAGE("Erreur a la lecture du lien : ");
    02354       SSCRUTE(nomlien);SSCRUTE(lien);
    02355       ret = -1;
    02356     } else {
    02357       lien[nval] = '\0';
    02358       printf("\t\t|%s|\n\n",lien);
    02359     }
    02360     free(lien);
    02361   }
    02362
    02363   /* Interrogation des localisations des points de GAUSS */
    02364   nloc = MEDnLocalization(fid);
    02365
    02366   printf("\nNombre de localisations stockees : "IFORMAT"\n\n",nloc);
    02367   for (i=1 ; i <= nloc ; i++ ) {
    02368     if ( MEDlocalizationInfo(fid, i, locname, &type_geo, &locsdim,&ngauss,
    02369                              geointerpname, ipointstructmeshname,&nsectionmeshcell,
    02370                              &sectiongeotype) < 0)  {
    02371       MESSAGE("Erreur a la demande d'information sur la localisation n° : "); ISCRUTE_int(i);
    02372       ret = -1;continue;
    02373     }
    02374     printf("\t- Loc. n°%i de nom |%s| de dimension "IFORMAT" avec "IFORMAT" pts de GAUSS \n",i,locname,locsdim,ngauss);
    02375     t1 = (type_geo%100)*(type_geo/100);
    02376     t2 = ngauss*(type_geo/100);
    02377     t3 = ngauss;
    02378     refcoo = (med_float *) malloc(sizeof(med_float)*t1 );
    02379     gscoo  = (med_float *) malloc(sizeof(med_float)*t2 );
    02380     wg     = (med_float *) malloc(sizeof(med_float)*t3 );
    02381
    02382     if ( MEDlocalizationRd(fid, locname, mode_coo, refcoo, gscoo, wg  ) < 0) {
    02383       MESSAGE("Erreur a la lecture des valeurs de la localisation : ");
    02384       SSCRUTE(locname);
    02385       ret = -1;
    02386     } else {
    02387       printf("\t  Coordonnees de l'element de reference de type %i :\n\t\t",type_geo);
    02388       for (j=0;j<t1;j++) printf(" %f ",*(refcoo+j));
    02389       printf("\n");
    02390       printf("\t  Localisation des points de GAUSS : \n\t\t");
    02391       for (j=0;j<t2;j++) printf(" %f ",*(gscoo+j));
    02392       printf("\n");
    02393       printf("\t  Poids associes aux points de GAUSS :\n\t\t");
    02394       for (j=0;j<t3;j++) printf(" %f ",*(wg+j));
    02395       printf("\n\n");
    02396     }
    02397     free(refcoo);
    02398     free(gscoo);
    02399     free(wg);
    02400   }
    02401
    02402   return;
    02403 }
    02404
    02405 /******************************************************************************
    02406  *
    02407  * - Nom de la fonction : lecture_parametres_scalaires
    02408  * - Description : lecture des parametres scalaires definis
    02409  *                 hors champs et maillages.
    02410  * - Parametres :
    02411  *     - fid                    (IN) : ID du fichier MED.
    02412  *     - lecture_en_tete_seule  (IN) : mode de lecture.
    02413  *
    02414  ******************************************************************************/
    02415
    02416 void lecture_parametres_scalaires(med_idt fid,
    02417                                   int lecture_en_tete_seulement)
    02418 {
    02419   med_err ret = 0;
    02420   char nom_scalaire[MED_NAME_SIZE+1];
    02421   char description[MED_COMMENT_SIZE+1];
    02422   med_int vali;
    02423   med_float valr;
    02424   med_int i,n,npdt,j;
    02425   med_parameter_type  type;
    02426   med_int numdt,numo;
    02427   med_float dt;
    02428   char dt_unit[MED_SNAME_SIZE+1];
    02429
    02430   fprintf(stdout,"\n(*******************************)\n");
    02431   fprintf(stdout,"(* VARIABLES SCALAIRES       : *)\n");
    02432   fprintf(stdout,"(*******************************)\n");
    02433
    02434   /* Combien de variables scalaire ? */
    02435   n = MEDnParameter(fid);
    02436   EXIT_IF(n < 0,"lors de la lecture du nombre de scalaires",NULL);
    02437   fprintf(stdout,"- Nombre de variables scalaires : %d\n",n);
    02438
    02439   if (lecture_en_tete_seulement)
    02440     return ;
    02441
    02442   for (i=1;i<=n;i++) {
    02443
    02444     /* Lecture des infos (type,description) */
    02445     ret = MEDparameterInfo( fid,i,nom_scalaire,&type,description,
    02446                             dt_unit, &npdt );
    02447     EXIT_IF(ret < 0,"lors de la lecture des parametres d'un scalaire",NULL);
    02448     fprintf(stdout,"- Scalaire n°%d de nom %s \n",i,nom_scalaire);
    02449     if (type == MED_FLOAT64)
    02450       fprintf(stdout,"  Type flottant. \n");
    02451     else
    02452       fprintf(stdout,"  Type entier. \n");
    02453     printf("  Description associee : [%s] \n",description);
    02454
    02455     /* Pour chaque scalaire on regarde les valeurs associees
    02456        eventuellement a des pas de temps et des numeros d'ordre */
    02457     EXIT_IF(npdt < 0,
    02458             "lors de la lecture du nombre de pas de temps d'un scalaire"
    02459             ,NULL);
    02460     fprintf(stdout,"   Nombre de valeurs stockees : %d \n",npdt);
    02461
    02462     for (j=1;j<=npdt;j++) {
    02463
    02464       ret = MEDparameterComputationStepInfo(fid,nom_scalaire,j, &numdt,&numo,&dt);
    02465       EXIT_IF(ret < 0,
    02466               "lors de la lecture des parametres d'un pas de temps d'un scalaire",
    02467               NULL);
    02468
    02469       if (numdt == MED_NO_DT)
    02470         fprintf(stdout,"   - Aucun de pas de temps \n");
    02471       else
    02472         fprintf(stdout,
    02473                 "   - Pas de de temps de numero %d de valeur %f [%s] \n",numdt,
    02474                dt,dt_unit);
    02475       if (numo == MED_NO_IT)
    02476         fprintf(stdout,"   - Aucun numero d'ordre \n");
    02477       else
    02478         fprintf(stdout,"   - Numero d'ordre : %d \n",numo);
    02479
    02480       if (type == MED_FLOAT64) {
    02481         ret = MEDparameterValueRd(fid,nom_scalaire,numdt,numo,(unsigned char * ) &valr);
    02482         fprintf(stdout,"   - Valeur : %f \n",valr);
    02483       }
    02484       else {
    02485         ret = MEDparameterValueRd(fid,nom_scalaire,numdt,numo,(unsigned char * ) &vali);
    02486         fprintf(stdout,"   - Valeur : %d \n",vali);
    02487       }
    02488       EXIT_IF(ret < 0,"lors de la lecture de la valeur d'un scalaire",NULL);
    02489
    02490     }
    02491   }
    02492
    02493   return ;
    02494 }
    02495
    02496 med_idt ouverture_fichier_MED(char *fichier)
    02497 {
    02498   med_idt fid;
    02499   med_err ret = 0;
    02500   med_int majeur,mineur,release;
    02501   med_bool    hdfok;
    02502   med_bool    medok;
    02503
    02504   /* on regarde si le fichier existe */
    02505   ret = (int) access(fichier,F_OK);
    02506   EXIT_IF(ret < 0,"Le fichier n'est pas accessible ou n'existe pas ",
    02507           fichier);
    02508
    02509   /* on regarde s'il s'agit d'un fichier au format HDF 5 */
    02510   ret = MEDfileCompatibility (fichier,&hdfok, &medok );
    02511   EXIT_IF(ret < 0,"Impossible de déterminer la compatibilité de format. ",
    02512           fichier);
    02513
    02514   EXIT_IF(!hdfok,"Le fichier n'est pas dans un format HDF compatible ", fichier);
    02515   EXIT_IF(!medok,"Le fichier n'est pas dans un format MED compatible ", fichier);
    02516
    02517   /* Quelle version de MED est utilise par mdump ? */
    02518   MEDlibraryNumVersion(&majeur,&mineur,&release);
    02519   fprintf(stdout,
    02520           "- Lecture du fichier à l'aide de la bibliotheque MED V%d.%d.%d \n",
    02521           majeur,mineur,release);
    02522
    02523   /* Ouverture du fichier MED en lecture seule */
    02524   fid = MEDfileOpen(fichier,MED_ACC_RDONLY);
    02525   EXIT_IF( fid < 0,"Ouverture du du fichier ",fichier);
    02526
    02527   MEDfileNumVersionRd(fid, &majeur, &mineur, &release);
    02528   EXIT_IF(( (majeur < 2) || ( (majeur == 2) && (mineur < 2)) ), "Le fichier est antérieur à la version 2.2", NULL);
    02529
    02530   return fid;
    02531 }
    02532
    02533 void lecture_en_tete(med_idt fid,char* fichier)
    02534 {
    02535   char fichier_en_tete[MED_COMMENT_SIZE+1];
    02536   med_err ret = 0;
    02537
    02538   /* lecture de l'en-tete du fichier (optionnel) */
    02539   /* on va lire dans le fichier */
    02540   ret = MEDfileCommentRd(fid,fichier_en_tete);
    02541
    02542   /* on affiche */
    02543   if (ret >= 0)
    02544     fprintf(stdout,"- En-tete du fichier : %s \n",fichier_en_tete);
    02545
    02546   return;
    02547 }
    02548
    02549 void parametrage(med_switch_mode *mode_coo,
    02550                  med_connectivity_mode *typ_con)
    02551 {
    02552   int reponse;
    02553
    02554   fprintf(stdout,"(*****************)\n");
    02555   fprintf(stdout,"(* PARAMETRAGE : *)\n");
    02556   fprintf(stdout,"(*****************)\n");
    02557   fprintf(stdout,"- Mode d'affichage des coordonnées des noeuds ? \n");
    02558   fprintf(stdout,"  1. Mode entrelacé : taper 1 \n");
    02559   fprintf(stdout,"  2. Mode non entrelacé : taper 2 \n");
    02560   reponse = 0;
    02561   do {
    02562     fprintf(stdout,"  Reponse : ");
    02563     scanf("%d",&reponse);
    02564   } while (reponse != 1 && reponse != 2);
    02565   if (reponse == 1)
    02566     *mode_coo = MED_FULL_INTERLACE;
    02567   else
    02568     *mode_coo = MED_NO_INTERLACE;
    02569
    02570   fprintf(stdout,"- Connectivité des éléments ? \n");
    02571   fprintf(stdout,"  1. Nodale : taper 1 \n");
    02572   fprintf(stdout,"  2. Descendante : taper 2 \n");
    02573   reponse = 0;
    02574   do {
    02575     fprintf(stdout,"  Reponse : ");
    02576     scanf("%d",&reponse);
    02577   } while (reponse != 1 && reponse != 2);
    02578   if (reponse == 1)
    02579     *typ_con = MED_NODAL;
    02580   else
    02581     *typ_con = MED_DESCENDING;
    02582
    02583   return;
    02584 }
    02585
    02586
    02587 void lecture_information_maillage(const med_idt fid,
    02588                                   const int numero,
    02589                                   char *          nommaa,
    02590                                   med_int * const mdim,
    02591                                   med_int * const edim,
    02592                                   med_mesh_type * const type_maillage,
    02593                                   char * const maillage_description,
    02594                                   med_int * const nstep,
    02595                                   char    * const dtunit,
    02596                                   char    * const nomcoo,
    02597                                   char    * const unicoo,
    02598                                   med_axis_type *const rep)
    02599 {
    02600   char nom_universel[MED_LNAME_SIZE+1];
    02601   med_err ret = 0;
    02602   med_sorting_type sortingtype;
    02603
    02604   fprintf(stdout,"\n(********************************************)\n");
    02605   fprintf(stdout,"(* INFORMATIONS GENERALES SUR LE MAILLAGE : *)\n");
    02606   fprintf(stdout,"(********************************************)\n");
    02607
    02608   /* lecture du nom et de la dimension du maillage */
    02609   ret = MEDmeshInfo(fid, numero,nommaa,edim,mdim,type_maillage,maillage_description,
    02610                     dtunit,&sortingtype,nstep,rep,nomcoo,unicoo);
    02611   EXIT_IF(ret < 0,"Lecture des informations sur le maillage",NULL);
    02612
    02613   /* affichage des donnees lues */
    02614   fprintf(stdout,"- Nom du maillage : <<%s>>\n",nommaa);
    02615   fprintf(stdout,"- Dimension du maillage : "IFORMAT"\n",*mdim);
    02616   if (*edim > *mdim)
    02617     fprintf(stdout,"- La dimension de l'espace est "IFORMAT" \n",*edim);
    02618   if (*type_maillage == MED_UNSTRUCTURED_MESH)
    02619     fprintf(stdout,"- Type du maillage : MED_NON_STRUCTURE \n");
    02620   else
    02621     fprintf(stdout,"- Type du maillage : MED_STRUCTURE \n");
    02622   fprintf(stdout,"- Description associee au maillage : %s\n",
    02623           maillage_description);
    02624
    02625   if ( *nstep > 1 )
    02626     fprintf(stdout,"- Nombre d'étapes de calcul associées au maillage : "IFORMAT"\n",
    02627             *nstep);
    02628   if (strlen(dtunit))
    02629     fprintf(stdout,"- Unité des dates d'étapes de calcul associées au maillage : %s\n",
    02630             dtunit);
    02631
    02632  /* lecture du nom universel (presence optionnelle) */
    02633   ret = MEDmeshUniversalNameRd(fid,nommaa,nom_universel);
    02634   if (ret == 0)
    02635    fprintf(stdout,"- Nom universel du maillage : %s \n",nom_universel);
    02636
    02637  return;
    02638 }
    02639
    02640 /******************************************************************************
    02641  *
    02642  * - Nom de la fonction : main
    02643  * - Description : fonction "main" de l'outil de DUMP d'un fichier MED.
    02644  * - Parametres :
    02645  *     - argc  (IN) : nombre d'arguments sur la ligne de commande.
    02646  *     - argv  (IN) : liste des arguments.
    02647  *
    02648  ******************************************************************************/
    02649
    02650 int main (int argc, char **argv)
    02651 {
    02652   med_err ret = 0;
    02653   med_idt fid;
    02654   int numero;
    02655   med_switch_mode mode_coo;
    02656   med_connectivity_mode typ_con;
    02657   int lecture_en_tete_seulement = 0;
    02658   med_int mdim,nmaa;
    02659   /* nom du maillage */
    02660   char nommaa[MED_NAME_SIZE+1];
    02661   char maillage_description[MED_COMMENT_SIZE+1];
    02662   med_mesh_type type_maillage;
    02663   med_int edim;
    02664   int decalage;
    02665   char nomcoo[3*MED_SNAME_SIZE+1]="";
    02666   char unicoo[3*MED_SNAME_SIZE+1]="";
    02667   char dtunit[MED_SNAME_SIZE+1]="";
    02668   med_int   nstep=0,numdt=MED_NO_DT,numit=MED_NO_IT;
    02669   int       csit=0;
    02670   med_float dt=0.0;
    02671   med_axis_type  rep;
    02672   /****************************************************************************
    02673   *                  TEST DU NOMBRE D'ARGUMENTS                               *
    02674   *                  argument 1 = nom du fichier MED                          *
    02675   ****************************************************************************/
    02676
    02677   structure = 0;
    02678   decalage = 0;
    02679   if (argc > 2 && strcmp(argv[1], "--structure") == 0) {
    02680     argc--;
    02681     decalage = 1;
    02682     structure = 1;
    02683   }
    02684
    02685   EXIT_IF(argc != 2 && argc != 5,"nombre de parametres incorrects\n",NULL);
    02686
    02687
    02688   /****************************************************************************
    02689   *                      OUVERTURE DU FICHIER EN LECTURE                      *
    02690   ****************************************************************************/
    02691   fid = ouverture_fichier_MED(argv[1 + decalage]);
    02692 /*   ICI;_MEDobjetsOuverts(fid); */
    02693
    02694   /****************************************************************************
    02695    *                     QUESTIONS PRELIMINAIRES                              *
    02696    *    1. Mode d'affichage des coordonnees (entrelace ou non) ?              *
    02697    *    2. Connectivite des elements (nodale ou descendante) ?                *
    02698    ***************************************************************************/
    02699   fprintf(stdout,"\n >>>>>> DUMP DU FICHIER %s >>>>>>\n",argv[1 + decalage]);
    02700
    02701   /* lecture et affichage de l'en-tete du fichier */
    02702   lecture_en_tete(fid,argv[1 + decalage]);
    02703 /*   ICI;_MEDobjetsOuverts(fid); */
    02704
    02705   if (argc == 2)
    02706     parametrage(&mode_coo,&typ_con);
    02707   else {
    02708     if (! strcmp(argv[3 + decalage],"NODALE"))
    02709       typ_con = MED_NODAL;
    02710     if (! strcmp(argv[3 + decalage],"DESCENDANTE"))
    02711       typ_con = MED_DESCENDING;
    02712
    02713     if (!strcmp(argv[4 + decalage],"NO_INTERLACE"))
    02714       mode_coo = MED_NO_INTERLACE;
    02715     if (!strcmp(argv[4 + decalage],"FULL_INTERLACE"))
    02716       mode_coo = MED_FULL_INTERLACE;
    02717     if (! strcmp(argv[4 + decalage],"LECTURE_EN_TETE_SEULEMENT"))
    02718       lecture_en_tete_seulement = 1;
    02719   }
    02720
    02721
    02722   /****************************************************************************
    02723    *                      QUEL MAILLAGE LIRE ?                                *
    02724    ***************************************************************************/
    02725   nmaa = MEDnMesh(fid);
    02726 /*   ICI;_MEDobjetsOuverts(fid); */
    02727
    02728   EXIT_IF(nmaa < 0,"lors de la lecture du nombre de maillages",NULL);
    02729
    02730   /* Quel maillage lire ? */
    02731   if (argc == 2) {
    02732     fprintf(stdout,"- Il y a %d maillages dans ce fichier \n",nmaa);
    02733     fprintf(stdout,"  Lequel voulez-vous lire (1|2|3|...|n) ?\n");
    02734     do {
    02735       fprintf(stdout,"  Reponse : ");
    02736       scanf("%d",&numero);
    02737     } while ( (numero > nmaa) || (numero <= 0) );
    02738   }
    02739   else {
    02740     numero = atoi(argv[2 + decalage]);
    02741     EXIT_IF(numero > nmaa || numero <= 0,"ce numero de maillage n'existe pas",
    02742             NULL);
    02743   }
    02744
    02745   /****************************************************************************
    02746    *                       PARAMETRES SCALAIRES                               *
    02747    ****************************************************************************/
    02748
    02749   /* on va lire l'ensemble des parametres scalaire */
    02750   lecture_parametres_scalaires(fid,lecture_en_tete_seulement);
    02751 /*   _MEDobjetsOuverts(fid); */
    02752
    02753   /****************************************************************************
    02754    *                       INFOS GENERALES SUR LE MAILLAGE                    *
    02755    ****************************************************************************/
    02756   lecture_information_maillage(fid,numero,nommaa,&mdim,&edim,&type_maillage,
    02757                                maillage_description,&nstep,dtunit,nomcoo,unicoo,&rep);
    02758 /*   _MEDobjetsOuverts(fid); */
    02759
    02760   for (csit=1; csit <= nstep; ++csit) {
    02761
    02762     ret = MEDmeshComputationStepInfo(fid, nommaa, csit, &numdt, &numit, &dt);
    02763     EXIT_IF(ret < 0,"lors de l'appel à MEDmeshComputationStepInfo",NULL);
    02764
    02765  /****************************************************************************
    02766   *                      LECTURE DU MAILLAGE ET DES RESULTATS ASSOCIES        *
    02767   ****************************************************************************/
    02768 /*   _MEDobjetsOuverts(fid); */
    02769
    02770       if (type_maillage == MED_UNSTRUCTURED_MESH)
    02771         lecture_maillage_non_structure(fid,nommaa,numdt,numit,mdim,edim,mode_coo,typ_con,
    02772                                        nomcoo,unicoo,&rep,lecture_en_tete_seulement);
    02773       else {
    02774         lecture_maillage_structure(fid,nommaa,numdt,numit,mdim,edim,mode_coo,
    02775                                    nomcoo,unicoo,lecture_en_tete_seulement);
    02776
    02777       }
    02778 /*   _MEDobjetsOuverts(fid); */
    02779       /* on lit ensuite les resultats associes au maillage selectionne */
    02780       lecture_resultats(fid,nommaa,numdt,numit,mode_coo,lecture_en_tete_seulement);
    02781 /*   _MEDobjetsOuverts(fid); */
    02782
    02783   }
    02784
    02785  /****************************************************************************
    02786  *                      FERMETURE DU FICHIER                                 *
    02787  ****************************************************************************/
    02788  ret = MEDfileClose(fid);
    02789  EXIT_IF(ret < 0,"lors de la fermeture du fichier",argv[1 + decalage]);
    02790
    02791  fprintf(stdout,"\n >>>>>> FIN DU DUMP DU FICHIER %s >>>>>>\n",argv[1 + decalage]);
    02792
    02793  return EXIT_SUCCESS;
    02794 }