mdump4.c
Aller à la documentation de ce fichier.
/* This file is part of MED.
*
* COPYRIGHT (C) 1999 - 2021 EDF R&D, CEA/DEN
* MED is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* MED is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with MED. If not, see <http://www.gnu.org/licenses/>.
*/
/******************************************************************************
* - Nom du fichier : mdump.c
*
* - Description : utilitaire de dump pour fichier MED
* Ce fichier contient les fonctions suivantes
* qui constituent des modeles de programmation
* pour une lecture generique d'un fichier MED :
* - lecture_maillage_non_structure () :
* 1. Noeuds.
* 2. Mailles.
* 3. Faces (connectivite descendante).
* 4. Aretes (connectivite descendante).
* 5. Familles.
* 6. Equivalences.
* 7. Joints.
* - lecture_maillage_structure () :
* 1. Noeuds.
* 2. Mailles.
* 3. Familles.
* 4. Equivalences.
* 5. Joints.
* - lecture_resultats () :
* 1. Champs de resultats relatifs à un maillage.
* - Entites :
* - Noeuds
* - Mailles
* - Faces
* - Aretes
* - Gestion des pas de temps et numeros d'ordre :
* valeurs associees a un ou plusieurs maillages sous
* un meme pas de temps.
* - Gestion des profils.
* - Gestion des liens vers des maillages distants
* - Gestion des points de Gauss :
* - localisation des points de Gauss.
* - lecture_parametres_scalaires () :
* - Valeurs scalaires entieres ou flottantes.
* - Gestion des pas de temps et numeros d'ordre.
* - main() : infos generales + lecture de tous les champs et
* du fichier MED passe en parametre.
*
*****************************************************************************/
#ifndef MESGERR
#define MESGERR 1
#endif
#ifdef __cplusplus
extern "C" {
#endif
#include <med.h>
#include <med_config.h>
#include <med_utils.h>
#include <med_misc.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#ifdef __cplusplus
}
#endif
#ifdef PPRO_NT
#define F_OK 0
#define snprintf _snprintf
#else
#include <unistd.h>
#endif
extern med_entity_type MED23MESH_GET_ENTITY_TYPE[MED_N_ENTITY_TYPES+2];
extern const char * const MED23MESH_GET_ENTITY_TYPENAME[MED_N_ENTITY_TYPES+2];
extern med_geometry_type MED23MESH_GET_CELL_GEOMETRY_TYPE[MED_N_CELL_FIXED_GEO+2];
extern const char * const MED23MESH_GET_CELL_GEOMETRY_TYPENAME[MED_N_CELL_FIXED_GEO+2];
extern med_geometry_type MED23MESH_GET_FACE_GEOMETRY_TYPE[MED_N_FACE_FIXED_GEO+2];
extern const char * const MED23MESH_GET_FACE_GEOMETRY_TYPENAME[MED_N_FACE_FIXED_GEO+2];
extern med_geometry_type MED23MESH_GET_EDGE_GEOMETRY_TYPE[MED_N_EDGE_FIXED_GEO+2];
extern const char * MED23MESH_GET_EDGE_GEOMETRY_TYPENAME[MED_N_EDGE_FIXED_GEO+2];
extern med_geometry_type MED23MESH_GET_NODE_GEOMETRY_TYPE[MED_N_NODE_FIXED_GEO+2];
extern const char * MED23MESH_GET_NODE_GEOMETRY_TYPENAME[MED_N_NODE_FIXED_GEO+2];
extern med_entity_type MED23FIELD_GET_ENTITY_TYPE[MED_N_ENTITY_TYPES+2];
extern const char * const MED23FIELD_GET_ENTITY_TYPENAME[MED_N_ENTITY_TYPES+2];
extern med_geometry_type MED23FIELD_GET_CELL_GEOMETRY_TYPE[MED_N_CELL_FIXED_GEO+2];
extern const char * const MED23FIELD_GET_CELL_GEOMETRY_TYPENAME[MED_N_CELL_FIXED_GEO+2];
extern med_geometry_type MED23FIELD_GET_FACE_GEOMETRY_TYPE[MED_N_FACE_FIXED_GEO+2];
extern const char * const MED23FIELD_GET_FACE_GEOMETRY_TYPENAME[MED_N_FACE_FIXED_GEO+2];
extern med_geometry_type MED23FIELD_GET_EDGE_GEOMETRY_TYPE[MED_N_EDGE_FIXED_GEO+2];
extern const char * MED23FIELD_GET_EDGE_GEOMETRY_TYPENAME[MED_N_EDGE_FIXED_GEO+2];
extern med_geometry_type MED23FIELD_GET_NODE_GEOMETRY_TYPE[MED_N_NODE_FIXED_GEO+2];
extern const char * MED23FIELD_GET_NODE_GEOMETRY_TYPENAME[MED_N_NODE_FIXED_GEO+2];
/* Stockage des fids des fichiers ouverts dans le cas où le montage des fichiers
distants est demandé (variable mountage)
*/
#define MDUMP_MAX_FILE_OPEN 200
#define MDUMP_MAX_FILE_OPEN_INIT {INIT2X(INIT10X(INIT10X(0))) }
typedef struct {
int n;
med_idt array[MDUMP_MAX_FILE_OPEN];
} FIDS_t;
FIDS_t FIDS ={1, MDUMP_MAX_FILE_OPEN_INIT};
/* Indique si on vérifie seulement la structure
Lecture complète du fichier mais pas d'affichage des données volumineuses
*/
int structure = 0;
/* types geometriques des mailles references dans le modele MED */
const med_geometry_type * const typmai = MED23MESH_GET_CELL_GEOMETRY_TYPE+1;
const med_geometry_type * const typfac = MED23MESH_GET_FACE_GEOMETRY_TYPE+1;
const med_geometry_type * const typare = MED23MESH_GET_EDGE_GEOMETRY_TYPE+1;
const char * const *nommai = MED23MESH_GET_CELL_GEOMETRY_TYPENAME+1;
const char * const *nomfac = MED23MESH_GET_FACE_GEOMETRY_TYPENAME+1;
const char * const *nomare = MED23MESH_GET_EDGE_GEOMETRY_TYPENAME+1;
#define MED_LECTURE_MAILLAGE_SUPPORT_UNIQUEMENT 2
#define MED_LECTURE_ENTETE_SEULEMENT 1
#define USER_MODE MED_COMPACT_STMODE
#define xstr(s) str(s)
#define str(s) #s
#define MIN(a,b) ((a) < (b) ? (a) : (b))
#define MAX(a,b) ((a) > (b) ? (a) : (b))
#define MAXBANNERLEN 255
/*Afficheurs pour la fonction polymorphique : MEDstructPrintFunction*/
void affd(const void *pva)
{
const double *pa = (const double *) pva;
printf(" %f ",*pa);
}
void affi(const void *pva)
{
const med_int *pa = (const med_int *) pva;
/* La ligne suivante ne fonctionne pas à cause du % contenu dans IFORMAT*/
/* printf(" %9"IFORMAT" " ,*pa); */
printf(" " IFORMAT " " ,*pa);
}
void affs(const void *pva)
{
const char *pa = (const char *) pva;
printf(" %.*s ",MED_NAME_SIZE,pa);
}
typedef void (*_myfuncptr)(const void*);
_myfuncptr MEDstructPrintFunction(med_attribute_type atttype) {
switch (atttype) {
case MED_ATT_INT :
return affi;
break;
case MED_ATT_FLOAT64:
return affd;
break;
case MED_ATT_NAME:
return affs;
break;
default:
EXIT_IF(-1,"lors de la lecture du type d'attribut à afficher.",NULL);
return NULL;
}
return NULL;
}
med_int lecture_nombre_famille(med_idt fid,const char * const nommaa)
{
med_int nfam = MEDnFamily(fid,nommaa);
EXIT_IF(nfam < 0,"lors de la lecture du nombre de familles",NULL);
fprintf(stdout,"- Nombre de familles : " IFORMAT " \n",nfam);
return nfam;
}
void lecture_famille_maillage(med_idt fid,const char * const nommaa,med_int nfam)
{
med_int i,j;
med_int natt,ngro;
char *attdes=NULL,*gro=NULL;
med_int *attval=NULL,*attide=NULL;
char nomfam[MED_NAME_SIZE+1];
med_int numfam;
char str1[MED_COMMENT_SIZE+1];
char str2[MED_LNAME_SIZE+1];
med_err ret = 0;
int famille_0 = 0;
if (nfam) {
fprintf(stdout,"\n(**************************)\n");
fprintf(stdout,"(* FAMILLES DU MAILLAGE : *)\n");
fprintf(stdout,"(**************************)\n");
}
for (i=0;i<nfam;i++) {
/* nombre de groupes */
ngro = MEDnFamilyGroup(fid,nommaa,i+1);
EXIT_IF(ngro < 0,"lors de la lecture du nombre de groupe d'une famille",
NULL);
/* nombre d'attributs */
natt = MEDnFamily23Attribute(fid,nommaa,i+1);
EXIT_IF(natt < 0,"lors de la lecture du nombre d'attributs d'une famille",
NULL);
fprintf(stdout,"- Famille " IFORMAT " a " IFORMAT " attributs et " IFORMAT " groupes \n",i+1,natt,
ngro);
/* nom,numero,attributs,groupes */
/* allocation memoire */
attide = (med_int*) malloc(sizeof(med_int)*natt);
EXIT_IF(attide == NULL,NULL,NULL);
attval = (med_int*) malloc(sizeof(med_int)*natt);
EXIT_IF(attval == NULL,NULL,NULL);
attdes = (char *) malloc(MED_COMMENT_SIZE*natt+1);
EXIT_IF(attdes == NULL,NULL,NULL);
gro = (char*) malloc(MED_LNAME_SIZE*ngro+1);
EXIT_IF(gro == NULL,NULL,NULL);
ret = MEDfamily23Info(fid,nommaa,i+1,nomfam,attide,attval,
attdes,&numfam,gro);
EXIT_IF(ret < 0,"lors de la lecture des informations d'une famille",
NULL);
if (numfam == 0)
famille_0 = 1;
if (!structure) {
/* affichage des resultats */
fprintf(stdout," - Famille de nom %s et de numero " IFORMAT " : \n",nomfam,numfam);
fprintf(stdout," - Attributs : \n");
for (j=0;j<natt;j++) {
strncpy(str1,attdes+j*MED_COMMENT_SIZE,MED_COMMENT_SIZE);
str1[MED_COMMENT_SIZE] = '\0';
fprintf(stdout," ide = " IFORMAT " - val = " IFORMAT " - des = %s\n",*(attide+j),
*(attval+j),str1);
}
}
/* on libere la memoire */
if (attide) {free(attide);attide=NULL;}
if (attval) {free(attval);attval=NULL;}
if (attdes) {free(attdes);attdes=NULL;}
if (!structure) {
fprintf(stdout," - Groupes :\n");
for (j=0;j<ngro;j++) {
strncpy(str2,gro+j*MED_LNAME_SIZE,MED_LNAME_SIZE);
str2[MED_LNAME_SIZE] = '\0';
fprintf(stdout," gro = %s\n",str2);
}
}
/* on libere la memoire */
if (gro) {free(gro);gro=NULL;}
}
if (famille_0 != 1) {
MESSAGE("Erreur : La famille FAMILLE_ZERO n'a pas été trouvée, elle est obligatoire. ");
}
return;
}
med_int lecture_nombre_equivalence(med_idt fid,const char * const nommaa)
{
med_int nequ = MEDnEquivalence(fid,nommaa);
EXIT_IF(nequ < 0,"lors de la lecture du nombre d'equivalences",NULL);
fprintf(stdout,"- Nombre d'equivalences : " IFORMAT " \n",nequ);
return nequ;
}
/* nombre de mailles concernees par les equivalences */
void lecture_equivalence_maillage(med_idt fid,const char * const nommaa,med_int nequ)
{
med_int i,j,k;
med_int ncor;
med_int *cor;
char equ[MED_NAME_SIZE+1];
char des[MED_COMMENT_SIZE+1];
med_err ret = 0;
med_int nstep=0,nocstpncor=0;
int _cstpit=0;
med_int _numdt,_numit;
if ( (nequ != 0) ) {
fprintf(stdout,"\n(******************************)\n");
fprintf(stdout,"(* EQUIVALENCES DU MAILLAGE : *)\n");
fprintf(stdout,"(******************************)\n");
}
/* lecture de toutes les equivalences associes a nommaa */
for (i = 0;i<nequ;i++) {
/* lecture des infos sur l'equivalence */
ret = MEDequivalenceInfo(fid,nommaa,i+1,equ,des,&nstep,&nocstpncor);
EXIT_IF(ret < 0,"lors de la lecture des informations sur une equivalence",
NULL);
/* if (!structure) { */
fprintf(stdout,"- Equivalence numero : " IFORMAT " ",i+1);
fprintf(stdout,"\n - Nom de l'equivalence: %s \n",equ);
fprintf(stdout,"\n - Description de l'equivalence : %s \n",des);
if (nstep > 1)
fprintf(stdout,"\n - L'equivalence est définie sur " IFORMAT " étapes de calcul\n",nstep);
/* } */
for (_cstpit=1; _cstpit <= nstep; ++_cstpit) {
ret = MEDequivalenceComputingStepInfo (fid, nommaa, equ, _cstpit,
& _numdt, &_numit,&nocstpncor);
EXIT_IF(ret < 0,
"lors de la lecture des valeurs d'étape de calcul d'une equivalence",
NULL);
if ( (_numdt != MED_NO_DT) || (_numit != MED_NO_IT) )
fprintf(stdout,"\n - Etape de calcul définie sur (numdt,numit) (" IFORMAT "," IFORMAT ") :\n",_numdt,_numit);
/* lecture des correspondances sur les differents types d'entites */
/* les noeuds */
ret = MEDequivalenceCorrespondenceSize(fid,nommaa,equ,_numdt,_numit,MED_NODE,MED_NONE,&ncor);
EXIT_IF(ret < 0,
"lors de la lecture du nombre de correspondances d'une equivalence",
NULL);
fprintf(stdout,"\n - Il y a " IFORMAT " correspondances sur les noeuds \n",ncor);
if (ncor > 0) {
/* allocation memoire */
cor = (med_int*) malloc(sizeof(med_int)*ncor*2);
EXIT_IF(cor == NULL,NULL,NULL);
ret= MEDequivalenceCorrespondenceRd(fid,nommaa,equ,_numdt,_numit,
MED_NODE,MED_NONE,cor);
EXIT_IF(ret < 0,"lors de la lecture du tableau des correspondances",
NULL);
if (!structure) {
for (j=0;j<ncor;j++)
fprintf(stdout,"\n - Correspondance " IFORMAT " : " IFORMAT " et " IFORMAT " \n",j+1,*(cor+2*j),
*(cor+2*j+1));
}
free(cor);
}
/* sur les mailles : */
for (j=0;j<MED_N_CELL_FIXED_GEO;j++) {
ret = MEDequivalenceCorrespondenceSize(fid,nommaa,equ,_numdt,_numit,MED_CELL,typmai[j],&ncor);
EXIT_IF(ret < 0,
"lors de la lecture du nombre de correspondances dans une equivalence",
NULL);
fprintf(stdout,"\n - Il y a " IFORMAT " correspondances sur les mailles %s \n",ncor,
nommai[j]);
if (ncor > 0) {
/* allocation memoire */
cor = (med_int*) malloc(sizeof(med_int)*ncor*2);
EXIT_IF(cor == NULL,NULL,NULL);
ret = MEDequivalenceCorrespondenceRd(fid,nommaa,equ,_numdt,_numit,
MED_CELL,typmai[j],cor);
EXIT_IF(ret < 0,"lors de la lecture du tableau des equivalences",
NULL);
if (!structure) {
for (k=0;k<ncor;k++)
fprintf(stdout,"\n - Correspondance " IFORMAT " : " IFORMAT " et " IFORMAT " \n",k+1,
*(cor+2*k),*(cor+2*k+1));
}
free(cor);
}
}
/* sur les faces */
for (j=0;j<MED_N_FACE_FIXED_GEO;j++) {
ret = MEDequivalenceCorrespondenceSize(fid,nommaa,equ,_numdt,_numit,
MED_DESCENDING_FACE,typfac[j],&ncor);
EXIT_IF(ret < 0,
"lors de la lecture du nombre de correspondances dans une equivalence",
NULL);
fprintf(stdout,"\n - Il y a " IFORMAT " correspondances sur les faces %s\n",ncor,
nomfac[j]);
if (ncor > 0) {
/* allocation memoire */
cor = (med_int*) malloc(sizeof(med_int)*ncor*2);
EXIT_IF(cor == NULL,NULL,NULL);
ret = MEDequivalenceCorrespondenceRd(fid,nommaa,equ,_numdt,_numit,
MED_DESCENDING_FACE,typfac[j],cor);
EXIT_IF(ret < 0,"lors de la lecture du tableau des equivalences",
NULL);
if (!structure) {
for (k=0;k<ncor;k++)
fprintf(stdout,"\n - Correspondance " IFORMAT " : " IFORMAT " et " IFORMAT " \n",k+1,*(cor+2*k),
*(cor+2*k+1));
}
free(cor);
}
}
/* sur les aretes */
for (j=0;j<MED_N_NODE_FIXED_GEO;j++) {
ret = MEDequivalenceCorrespondenceSize(fid,nommaa,equ,_numdt,_numit,
MED_DESCENDING_EDGE,typare[j],&ncor);
EXIT_IF(ret < 0,"lors de la lecture du nombre de correspondances",
NULL);
fprintf(stdout,"\n - Il y a " IFORMAT " correspondances sur les aretes %s \n",
ncor,nomare[j]);
if (ncor > 0) {
/* allocation memoire */
cor = (med_int*) malloc(sizeof(med_int)*ncor*2);
EXIT_IF(cor == NULL,NULL,NULL);
ret =MEDequivalenceCorrespondenceRd(fid,nommaa,equ,_numdt,_numit,
MED_DESCENDING_EDGE,typare[j],cor);
EXIT_IF(ret < 0,"lors de la lecture du tableau des equivalences",
NULL);
if (!structure) {
for (k=0;k<ncor;k++)
fprintf(stdout,"\n Correspondance " IFORMAT " : " IFORMAT " et " IFORMAT " \n",k+1,*(cor+2*k),
*(cor+2*k+1));
}
free(cor);
}
}
}
}
return;
}
med_int lecture_nombre_joint(med_idt fid,const char * const nommaa)
{
med_int njnt = MEDnSubdomainJoint(fid,nommaa);
EXIT_IF(njnt < 0,"lors de la lecture du nombre de joints",NULL);
fprintf(stdout,"- Nombre de joints : " IFORMAT " \n",njnt);
return njnt;
}
void lecture_joint_maillage(med_idt fid,const char * const nommaa,med_int njnt)
{
med_int i,k;
char des[MED_COMMENT_SIZE+1];
med_int ndom,nent;
med_entity_type typ_ent_local,typ_ent_distant;
med_int typ_geo_local,typ_geo_distant;
/* med_int geo_ent_local,geo_ent_distant; */
char jn [MED_NAME_SIZE+1]="";
char maa_dist [MED_NAME_SIZE+1]="";
char nom_geo_ent_local [MED_NAME_SIZE+1]="";
char nom_geo_ent_distant [MED_NAME_SIZE+1]="";
med_int *cortab;
med_err ret = 0;
med_int njstep=0,ncor=0,nodtitncor=0;
int corit=0,csit=0;
med_int _numdt,_numit;
if ( (njnt != 0) ) {
fprintf(stdout,"\n(******************************)\n");
fprintf(stdout,"(* JOINTS DU MAILLAGE : *)\n");
fprintf(stdout,"(******************************)\n");
}
/* lecture de tous les joints associes a nommaa */
for (i = 0;i<njnt;i++) {
fprintf(stdout,"\n- Joint numero : " IFORMAT " ",i+1);
/* lecture des infos sur le joint */
ret = MEDsubdomainJointInfo(fid,nommaa,i+1,jn,des,&ndom,maa_dist,&njstep,&nodtitncor);
EXIT_IF(ret < 0,"lors de la lecture des informations sur un joint",
NULL);
fprintf(stdout,"\n - Nom du joint: %s \n",jn);
fprintf(stdout,"\n - Description du joint : %s ",des);
fprintf(stdout,"\n - Domaine en regard : " IFORMAT " ",ndom);
fprintf(stdout,"\n - Maillage distant : %s ",maa_dist);
if (njstep > 1 ) {
printf("Nombre d'étapes de calcul : " IFORMAT " \n",njstep);
printf("Nombre de correspondance pour (NO_DT,NO_IT) : " IFORMAT " \n",nodtitncor);
}
for (csit=1; csit <= njstep; ++csit) {
ret = MEDsubdomainComputingStepInfo( fid, nommaa, jn, csit, &_numdt, &_numit, &ncor);
EXIT_IF(ret < 0,"Erreur a la lecture des valeurs (numdt,numit) dans les joints",
NULL);
if ( (_numdt != MED_NO_DT) || (_numit != MED_NO_IT) ) {
printf("Etape de calcul (numdt,numit) : (" IFORMAT "," IFORMAT ")\n",_numdt,_numit);
}
corit=1;
while ( corit <= ncor ) {
ret = MEDsubdomainCorrespondenceSizeInfo(fid,nommaa,jn,_numdt,_numit,corit,
(med_entity_type *) &typ_ent_local, (med_geometry_type *) &typ_geo_local,
(med_entity_type *) &typ_ent_distant,(med_geometry_type *)&typ_geo_distant,
&nent);
EXIT_IF(ret < 0,"Erreur a la lecture des infos sur le nombre d'entite en regard",
NULL);
if (nent > 0) {
if (typ_ent_local == MED_NODE) strcpy(nom_geo_ent_local,"MED_NOEUD");
else ret = _MEDgetInternalGeometryTypeName(fid,nom_geo_ent_local,typ_geo_local);
EXIT_IF(ret < 0,"Erreur à l'appel de _MEDgetInternalGeometryTypeName", NULL);
if (typ_ent_distant == MED_NODE) strcpy(nom_geo_ent_distant,"MED_NOEUD");
else ret = _MEDgetInternalGeometryTypeName(fid,nom_geo_ent_distant,typ_geo_distant);
EXIT_IF(ret < 0,"Erreur à l'appel de _MEDgetInternalGeometryTypeName", NULL);
fprintf(stdout,"\n\t\t- nb de couples d'entites en regard (local,distant)=(%s,%s) : " IFORMAT " \n",
nom_geo_ent_local,nom_geo_ent_distant, nent);
/*TODO : Supprimer la ligne suivante*/
/* fprintf(stdout," %d \n",nent); */
cortab = (med_int*) malloc(sizeof(med_int)*nent*2);
if ( (ret=MEDsubdomainCorrespondenceRd(fid,nommaa,jn,_numdt,_numit,
typ_ent_local,typ_geo_local,typ_ent_distant,typ_geo_distant,
cortab)) < 0) {
fprintf(stdout,"\n\t\t- Erreur a la lecture des correspondances sur (%s,%s,%s,%s)",
MED23MESH_GET_ENTITY_TYPENAME[typ_ent_local+1],nom_geo_ent_local,
MED23MESH_GET_ENTITY_TYPENAME[typ_ent_distant+1],nom_geo_ent_distant);
} else {
if (!structure) {
for (k=0;k<nent;k++)
fprintf(stdout,"\t\t- Correspondance " IFORMAT " : " IFORMAT " et " IFORMAT " \n",k+1,
*(cortab+2*k),*(cortab+2*k+1));
}
}
free(cortab);
} /*nent*/
corit++;
} /*ncor*/
} /*njstep*/
} /*njnt*/
return;
}
med_int lecture_nombre_noeuds_maillage_non_structure(const med_idt fid,
const char * nommaa,
const med_int numdt,
const med_int numit)
{
med_bool chgt=MED_FALSE,trsf=MED_FALSE;
med_int nnoe = MEDmeshnEntity(fid,nommaa,numdt,numit,
MED_NODE,MED_NO_GEOTYPE,
MED_COORDINATE,MED_NODAL,&chgt,&trsf);
EXIT_IF(nnoe < 0,"lors de la lecture du nombre de noeuds",NULL);
fprintf(stdout,"- Nombre de noeuds : " IFORMAT " \n",nnoe);
return nnoe;
}
void lecture_noeuds_maillage_non_structure(const med_idt fid,
const char * const nommaa,
const med_int numdt,
const med_int numit,
const med_int mdim,
const med_int edim,
const med_int nnoe,
const med_switch_mode mode_coo,
const char * const nomcoo,
const char * const unicoo,
const med_axis_type *const rep)
{
med_float *coo;
char *nomnoe;
med_int *numnoe;
med_int *nufano;
med_bool inonoe,inunoe,ifano;
med_err ret = 0;
med_int i;
char str[MED_SNAME_SIZE+1];
/* Allocations memoires */
/* table des coordonnees
profil : (dimension * nombre de noeuds ) */
coo = (med_float*) malloc(sizeof(med_float)*nnoe*edim);
EXIT_IF(coo == NULL,NULL,NULL);
/* table des numeros, des numeros de familles des noeuds
profil : (nombre de noeuds) */
numnoe = (med_int*) malloc(sizeof(med_int)*nnoe);
EXIT_IF(numnoe == NULL,NULL,NULL);
nufano = (med_int*) malloc(sizeof(med_int)*nnoe);
EXIT_IF(nufano == NULL,NULL,NULL);
/* table des noms des noeuds
profil : (nnoe*MED_SNAME_SIZE+1) */
nomnoe = (char*) malloc(MED_SNAME_SIZE*nnoe+1);
EXIT_IF(nomnoe == NULL,NULL,NULL);
/* lecture des noeuds :
- coordonnees
- noms (optionnel dans un fichier MED)
- numeros (optionnel dans un fichier MED)
- numeros des familles */
ret = MEDmeshNodeRd(fid,nommaa,numdt,numit, mode_coo, coo,
&inonoe,nomnoe,&inunoe,numnoe,&ifano,nufano);
EXIT_IF(ret < 0,"lors de la lecture des noeuds du maillage \n",NULL);
/* affichage des resultats */
if (nnoe) {
fprintf(stdout,"\n(************************)\n");
fprintf(stdout,"(* NOEUDS DU MAILLAGE : *)\n");
fprintf(stdout,"(************************)\n\n");
}
if (!structure) {
fprintf(stdout,"- Type de repere des coordonnees : %d \n",*rep);
fprintf(stdout,"- Nom des coordonnees : \n");
for (i=0;i<edim;i++) {
strncpy(str,nomcoo+i*MED_SNAME_SIZE,MED_SNAME_SIZE);
str[MED_SNAME_SIZE] = '\0';
fprintf(stdout," %s ",str);
}
fprintf(stdout,"\n- Unites des coordonnees : \n");
for (i=0;i<edim;i++) {
strncpy(str,unicoo+i*MED_SNAME_SIZE,MED_SNAME_SIZE);
str[MED_SNAME_SIZE] = '\0';
fprintf(stdout," %s ",str);
}
fprintf(stdout,"\n- Coordonnees des noeuds : ");
for (i=0;i<nnoe*edim;i++) {
if (mode_coo == MED_FULL_INTERLACE && !(i % edim))
fprintf(stdout,"\n [ %5" MED_IFORMAT " ] : ", (i/edim + 1) );
if (mode_coo == MED_NO_INTERLACE && ! (i % nnoe))
fprintf(stdout,"\n\n ");
fprintf(stdout," %-+9.6f ",*(coo+i));
}
if (inonoe) {
fprintf(stdout,"\n- Noms des noeuds : \n");
for (i=0;i<nnoe;i++) {
strncpy(str,nomnoe+i*MED_SNAME_SIZE,MED_SNAME_SIZE);
str[MED_SNAME_SIZE] = '\0';
fprintf(stdout," %s ",str);
}
}
if (inunoe) {
fprintf(stdout,"\n- Numeros des noeuds : \n");
for (i=0;i<nnoe;i++)
fprintf(stdout," " IFORMAT " ",*(numnoe+i));
}
fprintf(stdout,"\n- Numeros des familles des noeuds : \n");
for (i=0;i<nnoe;i++) {
if (ifano)
fprintf(stdout," " IFORMAT " ",*(nufano+i));
else
fprintf(stdout," %d ",0);
}
fprintf(stdout,"\n");
}
/* liberation memoire */
free(coo);
free(nomnoe);
free(numnoe);
free(nufano);
return;
}
med_int lecture_nombre_mailles_standards(const med_idt fid,
const char * const nommaa,
const med_int numdt,
const med_int numit,
const med_geometry_type typ_geo,
const med_connectivity_mode typ_con,
const int indice)
{
med_bool chgt=MED_FALSE,trsf=MED_FALSE;
med_int nmailles = MEDmeshnEntity(fid,nommaa,numdt,numit,
MED_CELL,typ_geo,
MED_CONNECTIVITY,typ_con,&chgt,&trsf);
EXIT_IF(nmailles < 0," lors de la lecture du nombre de mailles",NULL);
if ( (indice < (MED_N_CELL_GEO_FIXED_CON-5) ) ||
(indice >= (MED_N_CELL_GEO_FIXED_CON-5) && (nmailles > 0) ) )
if (nmailles)
fprintf (stdout,"- Nombre de mailles de type %s : " IFORMAT " \n",nommai[indice],
nmailles);
return nmailles;
}
med_int lecture_nombre_et_type_mailles_elstruct(const med_idt fid,
const char * const nommaa,
const med_int numdt,
const med_int numit,
const int indice,
med_geometry_type* geotype,
char* geotypename
)
{
med_bool chgt=MED_FALSE,trsf=MED_FALSE;
med_err _ret=-1;
med_int _nmailles=0;
_ret = MEDmeshEntityInfo(fid,nommaa,numdt,numit, MED_STRUCT_ELEMENT,
indice+1,geotypename,geotype );
EXIT_IF(_ret<0,
"Erreur à la demande d'informations pour le type d'entités MED_STRUCT_ELEMENT",NULL);
_nmailles = MEDmeshnEntity(fid,nommaa,numdt,numit,
MED_STRUCT_ELEMENT,*geotype,
MED_CONNECTIVITY,MED_NODAL,&chgt,&trsf);
EXIT_IF(_nmailles < 0," lors de la lecture du nombre de mailles",NULL);
if (_nmailles)
fprintf (stdout,"- Nombre de mailles de type %s : " IFORMAT " \n",geotypename, _nmailles);
return _nmailles;
}
void lecture_mailles_elstruct(const med_idt fid,
const char * const nommaa,
const med_int numdt,
const med_int numit,
const med_int nmodels,
const med_geometry_type* const geotype,
const char* const geotypename,
const med_int * const nmailles,
const med_switch_mode mode_coo)
{
med_err _ret=-1;
med_int taille=0;
char str[MED_SNAME_SIZE+1];
med_int *connectivite;
char *nomele;
med_int *numele;
med_int *nufael;
med_bool inoele=MED_FALSE, inuele=MED_FALSE, inufael=MED_FALSE;
med_geometry_type _geotype=MED_NONE;
med_int _elementdim=0;
char _supportmeshname[MED_NAME_SIZE+1]="";
med_entity_type _entitytype=MED_UNDEF_ENTITY_TYPE;
med_int _nnode=0;
med_int _ncell=0;
med_geometry_type _geocelltype=MED_NONE;
med_int _nconstantatribute=0;
med_bool _anyprofile=MED_FALSE;
med_int _nvariableattribute=0;
char _attname[MED_NAME_SIZE+1]="";
med_attribute_type _atttype;
med_int _atttypesize=0;
med_int _attvaluesize=0;
med_int _nattcomp=0;
void *_attvalue=NULL;
void (*_printf)(const void*);
int i=0,j=0,k=0;
med_int dispbanner=MED_FALSE;
for (i=0; i<nmodels; i++ ) {
_ret = MEDstructElementInfoByName(fid, &geotypename[i*(MED_NAME_SIZE+1)],
&_geotype,&_elementdim,
_supportmeshname,&_entitytype,&_nnode,&_ncell,
&_geocelltype,&_nconstantatribute,&_anyprofile,&_nvariableattribute);
if (_ncell > 0 )
taille=_ncell*_geocelltype%100;
else
taille = _nnode;
/* SSCRUTE(&geotypename[i*(MED_NAME_SIZE+1)]); */
/* ISCRUTE(_nnode); */
/* ISCRUTE(_ncell); */
/* ISCRUTE(taille); */
/* allocation memoire */
connectivite = (med_int*) calloc(taille*nmailles[i],sizeof(med_int));
EXIT_IF(connectivite == NULL,NULL,NULL);
nomele = (char*) malloc(sizeof(char)*MED_SNAME_SIZE*nmailles[i]+1);
EXIT_IF(nomele == NULL,NULL,NULL);
numele = (med_int*) malloc(sizeof(med_int)*nmailles[i]);
EXIT_IF(numele == NULL,NULL,NULL);
nufael = (med_int*) malloc(sizeof(med_int)*nmailles[i]);
EXIT_IF(nufael == NULL,NULL,NULL);
/* lecture des données */
_ret = MEDmeshElementRd( fid,nommaa,numdt,numit,MED_STRUCT_ELEMENT,geotype[i],
MED_NODAL, mode_coo, connectivite,
&inoele,nomele,&inuele,numele,&inufael,nufael );
EXIT_IF(_ret < 0,"lors de la lecture des mailles",NULL);
if ( !dispbanner) {
fprintf(stdout,"\n(***************************************)\n");
fprintf(stdout, "(* ELEMENTS DE STRUCTURE DU MAILLAGE : *)\n");
fprintf(stdout, "(***************************************)\n");
dispbanner=MED_TRUE;
}
if (!structure) {
/* affichage des resultats */
fprintf(stdout,"\n- Mailles de type %s : ", &geotypename[i*(MED_NAME_SIZE+1)]);
if (strcmp(&geotypename[i*(MED_NAME_SIZE+1)],"MED_PARTICLE") ) {
fprintf(stdout,"\n - Connectivité : ");
for (j=0;j<nmailles[i]*taille;j++) {
if (mode_coo == MED_FULL_INTERLACE && !(j % taille))
fprintf(stdout,"\n [ %5" MED_IFORMAT " ] : ", (j/taille +1) );
if (mode_coo == MED_NO_INTERLACE && !(j % nmailles[i]))
fprintf(stdout,"\n");
fprintf(stdout," %9" MED_IFORMAT " ",*(connectivite+j));
}
}
if (inoele) {
fprintf(stdout,"\n - Noms : \n");
for (j=0;j<nmailles[i];j++) {
strncpy(str,nomele+j*MED_SNAME_SIZE,MED_SNAME_SIZE);
str[MED_SNAME_SIZE] = '\0';
fprintf(stdout," %s ",str);
}
}
if (inuele) {
fprintf(stdout,"\n - Numeros :\n");
for (j=0;j<nmailles[i];j++)
fprintf(stdout," " IFORMAT " ",*(numele+j));
}
fprintf(stdout,"\n - Numéros de familles : \n");
for (j=0;j<nmailles[i];j++)
if (inufael)
fprintf(stdout," " IFORMAT " ",*(nufael+j));
else
fprintf(stdout," %d ",0);
fprintf(stdout,"\n");
}
/* Read variable attribute(s) */
for (k=0; k<_nvariableattribute; k++) {
/* read informations about the attribute */
_ret = MEDstructElementVarAttInfo(fid, &geotypename[i*(MED_NAME_SIZE+1)], k+1,
_attname, &_atttype, &_nattcomp);
EXIT_IF(_ret < 0,"lors de la lecture des caractéristiques de attributs variables",NULL);
/* Memory allocation */
EXIT_IF(_atttype == MED_ATT_UNDEF,"à la lecture du type (valeur : MED_ATT_UNDEF) de l'attribut variable ",_attname);
_atttypesize = MEDstructElementAttSizeof(_atttype);
_attvaluesize = nmailles[i]*_nattcomp*_atttypesize;
if ( _atttype == MED_ATT_NAME) ++_attvaluesize;
_attvalue = (void *) malloc( _attvaluesize*sizeof(char));
--_attvaluesize;
/* read attribute values */
_ret =MEDmeshStructElementVarAttRd(fid, nommaa, numdt, numit,
*(geotype+i), _attname, _attvalue );
if (_ret < 0 ) free(_attvalue);
EXIT_IF(_ret < 0,"lors de la lecture des attributs variables",NULL);
_printf=MEDstructPrintFunction(_atttype);
if (!structure) {
fprintf(stdout,"\n - Valeurs de l'attribut |%s| pour le type géométrique |%s| : \n",_attname,
&geotypename[i*(MED_NAME_SIZE+1)]);
for (j=0;j<nmailles[i]*_nattcomp;j++) {
if ( ( _nattcomp > 1 ) && !(j % _nattcomp) )
fprintf(stdout,"\n [ %5" MED_IFORMAT " ] : ", (j/_nattcomp +1) );
_printf( (void *)( (char *)(_attvalue) + j*_atttypesize) );
}
}
/* free memory */
free(_attvalue);
}
/* liberation memoire */
free(connectivite);
free(nomele);
free(numele);
free(nufael);
}
return;
}
void lecture_mailles_standards(const med_idt fid,
const char *nommaa,
const med_int numdt,
const med_int numit,
const med_int mdim,
const med_int * const nmailles,
const med_switch_mode mode_coo,
const med_connectivity_mode typ_con)
{
med_int taille;
med_int *connectivite;
char *nomele;
med_int *numele;
med_int *nufael;
med_bool inoele=MED_FALSE, inuele=MED_FALSE, inufael=MED_FALSE;
med_int entdim;
med_int nnodes;
med_int nndes;
med_int i,j;
med_err ret = 0;
char str[MED_SNAME_SIZE+1];
med_int dispbanner=MED_FALSE;
/* Lecture des connectivites, noms, numeros des mailles */
for (i=0;i<MED_N_CELL_GEO_FIXED_CON;i++)
if (nmailles[i] > 0) {
ret=_MEDgetGeometricParameter(MED_CELL, typmai[i],&entdim,&nnodes,&nndes);
EXIT_IF(ret < 0,"lors de la lecture des caractéristiques des mailles",NULL);
switch(typ_con) {
case MED_NODAL :
taille = nnodes;
break;
case MED_DESCENDING :
taille = nndes;
break;
default :
ret = -1;
}
/* allocation memoire */
connectivite = (med_int*) malloc(sizeof(med_int)*taille*nmailles[i]);
EXIT_IF(connectivite == NULL,NULL,NULL);
nomele = (char*) malloc(sizeof(char)*MED_SNAME_SIZE*nmailles[i]+1);
EXIT_IF(nomele == NULL,NULL,NULL);
numele = (med_int*) malloc(sizeof(med_int)*nmailles[i]);
EXIT_IF(numele == NULL,NULL,NULL);
nufael = (med_int*) malloc(sizeof(med_int)*nmailles[i]);
EXIT_IF(nufael == NULL,NULL,NULL);
/* lecture des données */
ret = MEDmeshElementRd( fid,nommaa,numdt,numit,MED_CELL,typmai[i],
typ_con, mode_coo, connectivite,
&inoele,nomele,&inuele,numele,&inufael,nufael );
EXIT_IF(ret < 0,"lors de la lecture des mailles",NULL);
if ( !dispbanner) {
fprintf(stdout,"\n(**************************)\n");
fprintf(stdout,"(* ELEMENTS DU MAILLAGE : *)\n");
fprintf(stdout,"(**************************)\n");
dispbanner=MED_TRUE;
}
if (!structure) {
/* affichage des resultats */
fprintf(stdout,"\n- Mailles de type %s : ", nommai[i]);
fprintf(stdout,"\n - Connectivité : ");
for (j=0;j<nmailles[i]*taille;j++) {
if (mode_coo == MED_FULL_INTERLACE && !(j % taille))
fprintf(stdout,"\n [ %5" MED_IFORMAT " ] : ", (j/taille +1) );
if (mode_coo == MED_NO_INTERLACE && !(j % nmailles[i]))
fprintf(stdout,"\n");
fprintf(stdout," %9" MED_IFORMAT " ",*(connectivite+j));
}
if (inoele) {
fprintf(stdout,"\n - Noms : \n");
for (j=0;j<nmailles[i];j++) {
strncpy(str,nomele+j*MED_SNAME_SIZE,MED_SNAME_SIZE);
str[MED_SNAME_SIZE] = '\0';
fprintf(stdout," %s ",str);
}
}
if (inuele) {
fprintf(stdout,"\n - Numeros :\n");
for (j=0;j<nmailles[i];j++)
fprintf(stdout," " IFORMAT " ",*(numele+j));
}
fprintf(stdout,"\n - Numéros de familles : \n");
for (j=0;j<nmailles[i];j++)
if (inufael)
fprintf(stdout," " IFORMAT " ",*(nufael+j));
else
fprintf(stdout," %d ",0);
fprintf(stdout,"\n");
}
/* liberation memoire */
free(connectivite);
free(nomele);
free(numele);
free(nufael);
}
return;
}
med_int lecture_nombre_mailles_polygones(const med_idt fid,
const char * const nommaa,
const med_int numdt,
const med_int numit,
const med_geometry_type polytype,
const med_connectivity_mode typ_con)
{
med_bool chgt=MED_FALSE,trsf=MED_FALSE;
char polytypename[MED_NAME_SIZE+1]="Undefined GeoType";
med_int nmpolygones;
EXIT_IF( (( polytype != MED_POLYGON) &&
( polytype != MED_POLYGON2) ),
MED_ERR_RANGE_MSG, MED_ERR_GEOMETRY_MSG);
nmpolygones = MEDmeshnEntity(fid,nommaa,numdt,numit,
MED_CELL,polytype,
MED_INDEX_NODE,typ_con,&chgt,&trsf);
EXIT_IF(nmpolygones < 0,"lors de la lecture du nombre de mailles polygone\n",
NULL);
if (nmpolygones > 0 ) nmpolygones--; else nmpolygones=0;
if (nmpolygones) {
MEDmeshGeotypeName(fid,polytype,polytypename);
fprintf(stdout,"- Nombre de mailles de type %s : " IFORMAT " \n",
polytypename,nmpolygones);
}
polytypename[0]='\0';
return nmpolygones;
}
void lecture_mailles_polygones(const med_idt fid,
const char * const nommaa,
const med_int numdt,
const med_int numit,
const med_geometry_type polytype,
const med_int nmpolygones,
const med_switch_mode mode_coo,
const med_connectivity_mode typ_con)
{
med_int i,j;
med_err ret = 0;
med_int taille;
med_int *connectivite;
char *nomele;
med_int *numele;
med_int *nufael;
med_int *indexp;
int ind1,ind2;
char tmp[MED_NAME_SIZE+1];
med_err ret1,ret2,ret3;
med_bool chgt=MED_FALSE,trsf=MED_FALSE;
char polytypename[MED_NAME_SIZE+1]="Undefined GeoType";
EXIT_IF( (( polytype != MED_POLYGON) &&
( polytype != MED_POLYGON2) ),
MED_ERR_RANGE_MSG, MED_ERR_GEOMETRY_MSG);
/* lecture des mailles de type MED_POLYGONE */
/* quelle taille pour le tableau des connectivites ? */
taille=MEDmeshnEntity(fid,nommaa,numdt,numit,
MED_CELL,polytype,MED_CONNECTIVITY,typ_con,
&chgt,&trsf);
EXIT_IF(taille < 0,"lors de la lecture des parametres des mailles polygones",
NULL);
/* allocation memoire */
indexp = (med_int *) malloc(sizeof(med_int)*(nmpolygones+1));
EXIT_IF(indexp == NULL,NULL,NULL);
connectivite = (med_int *) malloc(sizeof(med_int)*taille);
EXIT_IF(connectivite == NULL,NULL,NULL);
numele = (med_int *) malloc(sizeof(med_int)*nmpolygones);
EXIT_IF(numele == NULL,NULL,NULL);
nufael = (med_int *) malloc(sizeof(med_int)*nmpolygones);
EXIT_IF(nufael == NULL,NULL,NULL);
nomele = (char *) malloc(sizeof(char)*MED_SNAME_SIZE*nmpolygones+1);
EXIT_IF(nomele == NULL,NULL,NULL);
/* lecture de la connectivite des mailles polygones */
ret = MEDmeshPolygon2Rd(fid,nommaa,numdt,numit,MED_CELL,polytype,typ_con,
indexp,connectivite);
EXIT_IF(ret < 0,"lors de la lecture des connectivites des mailles polygones",
NULL);
/* lecture noms */
ret1 = MEDmeshEntityNameRd(fid,nommaa,numdt,numit,
MED_CELL,polytype, nomele);
/* lecture des numeros */
ret2 = (med_int) MEDmeshEntityNumberRd(fid,nommaa,numdt,numit,
MED_CELL, polytype, numele);
/* lecture des numeros de familles */
ret3 = MEDmeshEntityFamilyNumberRd(fid, nommaa, MED_NO_DT, MED_NO_IT,
MED_CELL, polytype, nufael);
if (!structure) {
/* affichage des resultats */
MEDmeshGeotypeName(fid,polytype,polytypename);
fprintf(stdout,"\n\n- Mailles de type %s : ",polytypename);
for (i=0;i<nmpolygones;i++) {
fprintf(stdout,"\n >> Maille MED_POLYGONE " IFORMAT " : \n",i+1);
fprintf(stdout,"\n - Connectivité : ");
ind1 = *(indexp+i)-1;
ind2 = *(indexp+i+1)-1;
for (j=ind1;j<ind2;j++)
printf(" " IFORMAT " ",*(connectivite+j));
if (ret1 == 0) {
strncpy(tmp,nomele+i*MED_SNAME_SIZE,MED_SNAME_SIZE);
tmp[MED_SNAME_SIZE] = '\0';
fprintf(stdout,"\n - Nom : %s \n",tmp);
}
if (ret2 == 0)
fprintf(stdout,"\n - Numero : " IFORMAT " \n",*(numele+i));
if ( ret3 >= 0 )
fprintf(stdout,"\n - Numéro de famille : " IFORMAT " \n",*(nufael+i));
else
fprintf(stdout,"\n - Numéro de famille : %d \n",0);
}
polytypename[0]='\0';
}
/* on libere la memoire */
free(indexp);
free(connectivite);
free(numele);
free(nufael);
free(nomele);
return;
}
med_int lecture_nombre_mailles_polyedres(const med_idt fid,
const char * const nommaa,
const med_int numdt,
const med_int numit,
const med_connectivity_mode typ_con)
{
med_bool chgt=MED_FALSE,trsf=MED_FALSE;
med_int npolyedres = MEDmeshnEntity(fid,nommaa,numdt,numit,
MED_CELL,MED_POLYHEDRON,
MED_INDEX_FACE,typ_con,&chgt,&trsf);
EXIT_IF(npolyedres < 0,"lors de la lecture du nombre de mailles polyedre \n",
NULL);
if ( npolyedres > 0 ) npolyedres--; else npolyedres=0;
if (npolyedres)
fprintf(stdout,"- Nombre de mailles de type MED_POLYEDRE : " IFORMAT " \n",
npolyedres);
return npolyedres;
}
void lecture_mailles_polyedres(const med_idt fid,
const char * const nommaa,
const med_int numdt,
const med_int numit,
const med_int npolyedres,
const med_switch_mode mode_coo,
const med_connectivity_mode typ_con)
{
med_int i,j,k;
med_err ret = 0;
med_int taille;
med_int *connectivite;
char *nomele;
med_int *numele;
med_int *nufael;
med_int *indexf, *indexn;
int ind1,ind2;
char tmp[MED_SNAME_SIZE+1];
med_err ret1,ret2,ret3;
med_int nfa;
med_int nnoe;
med_int nindn;
med_bool chgt=MED_FALSE,trsf=MED_FALSE;
/* lecture des parametres de base */
taille = MEDmeshnEntity(fid,nommaa,numdt,numit,
MED_CELL,MED_POLYHEDRON,MED_CONNECTIVITY,typ_con,
&chgt,&trsf);
EXIT_IF(taille < 0,"lors de la lecture des parametres des mailles polyedres",
NULL);
nindn = MEDmeshnEntity(fid,nommaa,numdt,numit,
MED_CELL,MED_POLYHEDRON,MED_INDEX_NODE,typ_con,
&chgt,&trsf);
EXIT_IF(nindn < 0,"lors de la lecture des parametres des mailles polyedres",
NULL);
/* allocation memoire */
/* nindf == npolyedres+1 */
indexf = (med_int *) malloc(sizeof(med_int)*(npolyedres+1));
EXIT_IF(indexf == NULL,NULL,NULL);
indexn = (med_int *) malloc(sizeof(med_int)*nindn);
EXIT_IF(indexn == NULL,NULL,NULL);
connectivite = (med_int *) malloc(sizeof(med_int)*taille);
EXIT_IF(connectivite == NULL,NULL,NULL);
numele = (med_int *) malloc(sizeof(med_int)*npolyedres);
EXIT_IF(numele == NULL,NULL,NULL);
nufael = (med_int *) malloc(sizeof(med_int)*npolyedres);
EXIT_IF(nufael == NULL,NULL,NULL);
nomele = (char *) malloc(sizeof(char)*MED_SNAME_SIZE*npolyedres+1);
EXIT_IF(nomele == NULL,NULL,NULL);
ret = MEDmeshPolyhedronRd(fid,nommaa,numdt,numit,MED_CELL,typ_con,
indexf,indexn,connectivite);
EXIT_IF(ret < 0,
"lors de la lecture de la connectivite des mailles polyedres",
NULL);
/* lecture des noms */
ret1 = MEDmeshEntityNameRd(fid,nommaa,numdt,numit,MED_CELL,MED_POLYHEDRON,nomele);
/* lecture des numeros */
ret2 = MEDmeshEntityNumberRd(fid,nommaa,numdt,numit,MED_CELL,MED_POLYHEDRON,numele);
/* lecture des numeros de familles */
ret3 = MEDmeshEntityFamilyNumberRd(fid,nommaa,numdt,numit,MED_CELL,MED_POLYHEDRON,nufael);
if (!structure) {
/* affichage des resultats */
fprintf(stdout,"\n\n- Mailles de type MED_POLYEDRE : ");
for (i=0;i<npolyedres;i++) {
fprintf(stdout,"\n >> Maille MED_POLYEDRE " IFORMAT " : \n",i+1);
fprintf(stdout,"\n - Connectivité : \n");
nfa = *(indexf+i+1) - *(indexf+i);
/* ind1 = indice dans "faces" pour acceder aux numeros des faces */
ind1 = *(indexf+i) - 1;
for (j=0;j<nfa;j++) {
if (typ_con == MED_NODAL) {
/* ind2 = indice dans "connectivite"
pour acceder au premier noeud de la face */
ind2 = *(indexn+ind1+j) - 1;
nnoe = *(indexn+ind1+j+1) - *(indexn+ind1+j);
fprintf(stdout," - Face " IFORMAT " : [ ", j+1);
for (k=0;k<nnoe;k++)
printf(" " IFORMAT " ",*(connectivite+ind2+k));
printf(" ] \n");
}
else {
nfa = *(indexf+i+1) - *(indexf+i);
/* ind1 = indice dans "connectivite"
pour acceder aux numeros des faces */
ind1 = *(indexf+i) - 1;
for (j=0;j<nfa;j++)
fprintf(stdout," - Face " IFORMAT " de numero : " IFORMAT " et de type " IFORMAT " \n", j+1,
*(connectivite+ind1+j),*(indexn+ind1+j));
}
}
if (ret1 == 0) {
strncpy(tmp,nomele+i*MED_SNAME_SIZE,MED_SNAME_SIZE);
tmp[MED_SNAME_SIZE] = '\0';
fprintf(stdout,"\n - Nom : %s \n",tmp);
}
if (ret2 == 0)
fprintf(stdout,"\n - Numero : " IFORMAT " \n",*(numele+i));
if (ret3 >= 0)
fprintf(stdout,"\n - Numéro de famille : " IFORMAT " \n",*(nufael+i));
else
fprintf(stdout,"\n - Numéro de famille : %d \n",0);
}
}
/* on libere la memoire */
free(indexf);
free(indexn);
free(connectivite);
free(numele);
free(nufael);
free(nomele);
return;
}
med_int lecture_nombre_faces_standards(const med_idt fid,
const char * const nommaa,
const med_int numdt,
const med_int numit,
const med_geometry_type typ_geo,
const med_int indice
)
{
med_bool chgt=MED_FALSE,trsf=MED_FALSE;
med_int nfaces = MEDmeshnEntity(fid,nommaa,numdt,numit,
MED_DESCENDING_FACE,typ_geo,
MED_CONNECTIVITY,MED_DESCENDING,&chgt,&trsf);
EXIT_IF(nfaces < 0,"lors de la lecture du nombre de faces",NULL);
if ( (indice < (MED_N_FACE_GEO_FIXED_CON-2) ) ||
(indice >= (MED_N_FACE_GEO_FIXED_CON-2) && (nfaces > 0) ) )
if (nfaces)
fprintf (stdout,"- Nombre de faces de type %s : " IFORMAT " \n",
nomfac[indice],nfaces);
return nfaces;
}
void lecture_faces_standard(const med_idt fid,
const char * const nommaa,
const med_int numdt,
const med_int numit,
const med_int mdim,
const med_int *const nfaces,
const med_switch_mode mode_coo)
{
med_int taille;
med_int *connectivite;
char *nomele;
med_int *numele;
med_int *nufael;
med_bool inoele,inuele,inufael;
med_int i,j;
med_err ret = 0;
char str[MED_SNAME_SIZE+1];
med_int entdim;
med_int nnodes;
for (i=0;i<MED_N_FACE_GEO_FIXED_CON;i++)
if (nfaces[i] > 0 ) {
/* taille de la description : nombre d'aretes */
ret=_MEDgetGeometricParameter(MED_DESCENDING_FACE, typfac[i],&entdim,&nnodes,&taille);
EXIT_IF(ret < 0,"lors de la lecture des caractéristiques des mailles",NULL);
/* allocation memoire */
connectivite = (med_int*)malloc(sizeof(med_int)*taille*nfaces[i]);
EXIT_IF(connectivite == NULL,NULL,NULL);
nomele = (char*)malloc(sizeof(char)*MED_SNAME_SIZE*nfaces[i]+1);
EXIT_IF(nomele == NULL,NULL,NULL);
numele = (med_int*)malloc(sizeof(med_int)*nfaces[i]);
EXIT_IF(numele == NULL,NULL,NULL);
nufael = (med_int*)malloc(sizeof(med_int)*nfaces[i]);
EXIT_IF(nufael == NULL,NULL,NULL);
/* lecture des données */
ret = MEDmeshElementRd( fid,nommaa,numdt,numit,MED_DESCENDING_FACE,typmai[i],
MED_DESCENDING, mode_coo, connectivite,
&inoele,nomele,&inuele,numele,&inufael,nufael );
EXIT_IF(ret < 0,"lors de la lecture des faces",NULL);
if (!structure) {
/* affichage des resultats */
fprintf(stdout,"\n- Faces de type %s : ", nomfac[i]);
fprintf(stdout,"\n - Connectivité : ");
for (j=0;j<nfaces[i]*taille;j++) {
if (mode_coo == MED_FULL_INTERLACE && !(j % taille))
fprintf(stdout,"\n [ %5" MED_IFORMAT " ] : ", (j/taille+1) );
if (mode_coo == MED_NO_INTERLACE && !(j % nfaces[i]))
fprintf(stdout,"\n");
fprintf(stdout," %9" MED_IFORMAT " ",*(connectivite+j));
}
if (inoele) {
fprintf(stdout,"\n - Noms : \n");
for (j=0;j<nfaces[i];j++) {
strncpy(str,nomele+j*MED_SNAME_SIZE,MED_SNAME_SIZE);
str[MED_SNAME_SIZE] = '\0';
fprintf(stdout," %s ",str);
}
}
if (inuele) {
fprintf(stdout,"\n - Numeros :\n");
for (j=0;j<nfaces[i];j++)
fprintf(stdout," " IFORMAT " ",*(numele+j));
}
fprintf(stdout,"\n - Numéros de familles : \n");
for (j=0;j<nfaces[i];j++)
if ( inufael )
fprintf(stdout," " IFORMAT " ",*(nufael+j));
else
fprintf(stdout," %d ",0);
}
/* liberation memoire */
free(connectivite);
free(nomele);
free(numele);
free(nufael);
}
return;
}
med_int lecture_nombre_faces_polygones(const med_idt fid,
const char * const nommaa,
const med_int numdt,
const med_int numit)
{
med_bool chgt=MED_FALSE,trsf=MED_FALSE;
med_int nfpolygones = MEDmeshnEntity(fid,nommaa,numdt,numit,
MED_CELL,MED_POLYGON,
MED_INDEX_NODE,MED_DESCENDING,&chgt,&trsf);
EXIT_IF(nfpolygones < 0,"lors de la lecture du nombre de faces polygone \n",
NULL);
if (nfpolygones > 0 ) nfpolygones--; else nfpolygones=0;
if (nfpolygones)
fprintf(stdout,"- Nombre de faces de type MED_POLYGONE : " IFORMAT " \n",
nfpolygones);
return nfpolygones;
}
void lecture_faces_polygones(const med_idt fid,
const char * const nommaa,
const med_int numdt,
const med_int numit,
const med_int nfpolygones,
const med_switch_mode mode_coo)
{
med_int i,j;
med_err ret = 0;
char *nomele;
med_int *numele;
med_int *nufael;
med_int *connectivite;
med_int taille;
med_int *indexp;
int ind1,ind2;
char tmp[MED_NAME_SIZE+1];
med_err ret1,ret2,ret3;
med_bool chgt=MED_FALSE,trsf=MED_FALSE;
/* quelle taille pour le tableau des connectivites ? */
taille=MEDmeshnEntity(fid,nommaa,numdt,numit,
MED_DESCENDING_FACE,MED_POLYGON,MED_CONNECTIVITY,MED_DESCENDING,
&chgt,&trsf);
EXIT_IF(taille < 0,"lors de la lecture des parametres des faces polygones",
NULL);
/* allocation memoire */
indexp = (med_int *) malloc(sizeof(med_int)*(nfpolygones+1));
EXIT_IF(indexp == NULL,NULL,NULL);
connectivite = (med_int *) malloc(sizeof(med_int)*taille);
EXIT_IF(connectivite == NULL,NULL,NULL);
numele = (med_int *) malloc(sizeof(med_int)*nfpolygones);
EXIT_IF(numele == NULL,NULL,NULL);
nufael = (med_int *) malloc(sizeof(med_int)*nfpolygones);
EXIT_IF(nufael == NULL,NULL,NULL);
nomele = (char *) malloc(sizeof(char)*MED_SNAME_SIZE*nfpolygones+1);
EXIT_IF(nomele == NULL,NULL,NULL);
/* lecture de la connectivite des faces polygones */
ret = MEDmeshPolygonRd(fid,nommaa,numdt,numit,MED_DESCENDING_FACE,MED_DESCENDING,
indexp,connectivite);
EXIT_IF(ret < 0,"lors de la lecture des connectivites des faces polygones", NULL);
/* lecture noms */
ret1 = MEDmeshEntityNameRd(fid,nommaa,numdt,numit,
MED_DESCENDING_FACE,MED_POLYGON, nomele);
/* lecture des numeros */
ret2 = (med_int) MEDmeshEntityNumberRd(fid,nommaa,numdt,numit,
MED_DESCENDING_FACE, MED_POLYGON, numele);
/* lecture des numeros de familles */
ret3 = MEDmeshEntityFamilyNumberRd(fid, nommaa, MED_NO_DT, MED_NO_IT,
MED_DESCENDING_FACE, MED_POLYGON, nufael);
if (!structure) {
/* affichage des resultats */
fprintf(stdout,"\n\n- Faces de type MED_POLYGONE : ");
for (i=0;i<nfpolygones;i++) {
fprintf(stdout,"\n >> Face MED_POLYGONE " IFORMAT " : \n",i+1);
fprintf(stdout,"\n - Connectivité : ");
ind1 = *(indexp+i)-1;
ind2 = *(indexp+i+1)-1;
for (j=ind1;j<ind2;j++)
fprintf(stdout," " IFORMAT " ",*(connectivite+j));
if (ret1 == 0) {
strncpy(tmp,nomele+j*MED_SNAME_SIZE,MED_SNAME_SIZE);
tmp[MED_SNAME_SIZE] = '\0';
fprintf(stdout,"\n - Nom : %s \n",tmp);
}
if (ret2 == 0)
fprintf(stdout,"\n - Numero : " IFORMAT " \n",*(numele+j));
if ( ret3 > 0 )
fprintf(stdout,"\n - Numéro de famille : " IFORMAT " \n",*(nufael+i));
else
fprintf(stdout,"\n - Numéro de famille : %d \n",0);
}
}
/* on libere la memoire */
free(indexp);
free(connectivite);
free(numele);
free(nufael);
free(nomele);
return;
}
med_int lecture_nombre_aretes_standards(const med_idt fid,
const char *const nommaa,
const med_int numdt,
const med_int numit,
const med_geometry_type typ_geo,
const med_int indice)
{
med_bool chgt=MED_FALSE,trsf=MED_FALSE;
med_int naretes = MEDmeshnEntity(fid,nommaa,numdt,numit,
MED_DESCENDING_EDGE, typ_geo,
MED_CONNECTIVITY,MED_DESCENDING,&chgt,&trsf);
EXIT_IF(naretes < 0,"lors de la lecture du nombre d'aretes",NULL);
if ( (indice < (MED_N_EDGE_GEO_FIXED_CON-1) ) ||
(indice >= (MED_N_EDGE_GEO_FIXED_CON-1) && (naretes > 0) ) )
if (naretes)
fprintf (stdout,
"- Nombre d'aretes de type %s : " IFORMAT " \n",nomare[indice],naretes);
return naretes;
}
void lecture_aretes_standards(const med_idt fid,
const char * const nommaa,
const med_int numdt,
const med_int numit,
const med_int mdim,
const med_int * const naretes,
const med_switch_mode mode_coo)
{
med_int taille;
med_int *connectivite;
char *nomele;
med_int *numele;
med_int *nufael;
med_bool inoele,inuele,inufael;
med_int i,j;
med_err ret = 0;
char str[MED_SNAME_SIZE+1];
med_int entdim;
med_int nnodes;
for (i=0;i<MED_N_EDGE_GEO_FIXED_CON;i++)
if (naretes[i] > 0) {
ret=_MEDgetGeometricParameter(MED_DESCENDING_EDGE, typare[i],&entdim,&nnodes,&taille);
EXIT_IF(ret < 0,"lors de la lecture des caractéristiques des mailles",NULL);
/* allocation memoire */
connectivite = (med_int*)malloc(sizeof(med_int)*taille*naretes[i]);
EXIT_IF(connectivite == NULL,NULL,NULL);
nomele = (char*)malloc(sizeof(char)*MED_SNAME_SIZE*naretes[i]+1);
EXIT_IF(nomele == NULL,NULL,NULL);
numele = (med_int*)malloc(sizeof(med_int)*naretes[i]);
EXIT_IF(numele == NULL,NULL,NULL);
nufael = (med_int*)malloc(sizeof(med_int)*naretes[i]);
EXIT_IF(nufael == NULL,NULL,NULL);
/* lecture des données */
ret = MEDmeshElementRd( fid,nommaa,numdt,numit,MED_DESCENDING_EDGE,typare[i],
MED_DESCENDING, mode_coo, connectivite,
&inoele,nomele,&inuele,numele,&inufael,nufael );
EXIT_IF(ret < 0,"lors de la lecture des aretes",
NULL);
if (!structure) {
/* affichage des resultats */
fprintf(stdout,"\n- Aretes de type %s : ", nomare[i]);
fprintf(stdout,"\n - Connectivité : ");
for (j=0;j<naretes[i]*taille;j++) {
if (mode_coo == MED_FULL_INTERLACE && !(j % taille))
fprintf(stdout,"\n [ %5" MED_IFORMAT " ] : ", (j/taille+1) );
if (mode_coo == MED_NO_INTERLACE && !(j % naretes[i]))
fprintf(stdout,"\n");
fprintf(stdout," %9" MED_IFORMAT " ",*(connectivite+j));
}
if (inoele) {
fprintf(stdout,"\n - Noms : \n");
for (j=0;j<naretes[i];j++) {
strncpy(str,nomele+j*MED_SNAME_SIZE,MED_SNAME_SIZE);
str[MED_SNAME_SIZE] = '\0';
fprintf(stdout," %s ",str);
}
}
if (inuele) {
fprintf(stdout,"\n - Numeros :\n");
for (j=0;j<naretes[i];j++)
fprintf(stdout," " IFORMAT " ",*(numele+j));
}
fprintf(stdout,"\n - Numéros de familles : \n");
for (j=0;j<naretes[i];j++)
if ( inufael )
fprintf(stdout," " IFORMAT " ",*(nufael+j));
else
fprintf(stdout," %d ",0);
}
/* liberation memoire */
free(connectivite);
free(nomele);
free(numele);
free(nufael);
}
return;
}
/******************************************************************************
* - Nom de la fonction : lecture_maillage_non_structure
* - Description : lecture et affichage d'un maillage MED_NON_STRUCTURE.
* - Parametres :
* - fid (IN) : ID du fichier MED.
* - nommaa (IN) : nom du maillage a lire.
* - mdim (IN) : dimension du maillage.
* - mode_coo (IN) : mode de stockage en memoire :
* MED_FULL_INTERLACE : entrelace |
* MED_NO_INTERLACE : non entrelace.
* - typ_con (IN) : mode de connectivite :
* MED_DESCENDING : descendante |
* MED_NODAL : nodale.
* - lecture_en_tete_seulement (IN) : mode de lecture et d'affichage.
******************************************************************************/
void lecture_maillage_non_structure(med_idt fid,
const char *nommaa,
const med_int numdt,
const med_int numit,
const med_int mdim,
const med_int edim,
const med_switch_mode mode_coo,
const med_connectivity_mode typ_con,
const char * const nomcoo,
const char * const unicoo,
const med_axis_type *const rep,
med_int* nmodels,
med_geometry_type** geotype_elst,
char** geotypename_elst,
const int lecture_en_tete_seulement)
{
med_int i;
/* nombre d'objets MED : noeuds, mailles, faces, aretes , ... */
med_int nnoe;
med_int nmailles[MED_N_CELL_GEO_FIXED_CON];
med_int nfaces[MED_N_FACE_GEO_FIXED_CON];
med_int naretes[MED_N_EDGE_GEO_FIXED_CON];
/* polygones et polyedres */
med_int nmpolygones,nmpolygones2, npolyedres, nfpolygones;
/* familles */
med_int nfam;
/* equivalences */
med_int nequ;
/* joints */
med_int njnt;
/* Eléments de structure */
med_int _nmodels=0,*_nmailles_elst = NULL;
med_geometry_type *_geotype_elst = NULL;
char *_geotypename_elst = NULL;
med_bool chgt=MED_FALSE,trsf=MED_FALSE;
/* Combien de noeuds dans le maillage ? */
nnoe = lecture_nombre_noeuds_maillage_non_structure(fid,nommaa,numdt,numit);
/* Combien de types d'éléments de structure utilisés dans le maillage */
_nmodels = MEDmeshnEntity(fid,nommaa,numdt,numit,
MED_STRUCT_ELEMENT,MED_GEO_ALL,MED_UNDEF_DATATYPE,MED_UNDEF_CONNECTIVITY_MODE,
&chgt,&trsf);
EXIT_IF(_nmodels<0,
"Erreur à la lecture du nombre de type géométrique pour le type d'entités MED_STRUCT_ELEMENT",NULL);
_nmailles_elst = (med_int *) malloc(_nmodels*sizeof(med_int));
_geotype_elst = (med_geometry_type *) malloc(_nmodels*sizeof(med_geometry_type));
_geotypename_elst = (char *) malloc(_nmodels*sizeof(char)*(MED_NAME_SIZE+1));
/* Combien mailles par types d'éléments de structure */
for (i=0; i < _nmodels; i++) {
_nmailles_elst[i]=lecture_nombre_et_type_mailles_elstruct(fid,nommaa,numdt,numit,i,
&_geotype_elst[i],&_geotypename_elst[i*(MED_NAME_SIZE+1)]);
}
if (_nmodels) {
*nmodels = _nmodels;
*geotype_elst = _geotype_elst;
*geotypename_elst = _geotypename_elst;
} else *nmodels=0;
/*TODO : AFFICHER DT ( DTUNIT ) */
/* Combien de mailles, faces ou aretes pour chaque type geometrique ? */
for (i=0;i<MED_N_CELL_GEO_FIXED_CON;i++)
nmailles[i] = lecture_nombre_mailles_standards(fid,nommaa,numdt,numit,typmai[i],
typ_con,i);
/* Combien de mailles polygones simples */
nmpolygones = lecture_nombre_mailles_polygones(fid,nommaa,numdt,numit,MED_POLYGON,typ_con);
/* Combien de mailles polygones quadratiques */
nmpolygones2 = lecture_nombre_mailles_polygones(fid,nommaa,numdt,numit,MED_POLYGON2,typ_con);
/* Combien de mailles polyedres quelconques ? */
npolyedres = lecture_nombre_mailles_polyedres(fid,nommaa,numdt,numit,typ_con);
/* Pour la connectivite descendante */
if (typ_con == MED_DESCENDING) {
/* Combien de faces : types geometriques standards ? */
for (i=0;i<MED_N_FACE_GEO_FIXED_CON;i++)
nfaces[i] = lecture_nombre_faces_standards(fid,nommaa,numdt,numit,typfac[i],i);
/* Combien de faces polygones quelconques ? */
nfpolygones = lecture_nombre_faces_polygones(fid,nommaa,numdt,numit);
/* Combien d'aretes */
for (i=0;i<MED_N_EDGE_GEO_FIXED_CON;i++)
naretes[i] = lecture_nombre_aretes_standards(fid,nommaa,numdt,numit,typare[i],i);
}
if (lecture_en_tete_seulement != MED_LECTURE_MAILLAGE_SUPPORT_UNIQUEMENT) {
/* combien de familles ? */
nfam = lecture_nombre_famille(fid,nommaa);
/* combien d'equivalences ? */
nequ = lecture_nombre_equivalence(fid,nommaa);
/* combien de joints ? */
njnt = lecture_nombre_joint(fid,nommaa);
}
/* en fonction du mode de lecture, on continue ou non */
if (lecture_en_tete_seulement == MED_LECTURE_ENTETE_SEULEMENT) {
/* Ces desallocations sont effectuées
après la lecture des champs sur ces éléments de structure */
/* free(_nmailles_elst); */
/* free(_geotype_elst); */
/* free(_geotypename_elst); */
return;
}
/****************************************************************************
* LECTURE DES NOEUDS *
****************************************************************************/
lecture_noeuds_maillage_non_structure(fid,nommaa,numdt,numit,mdim,edim,nnoe,mode_coo,nomcoo,unicoo,rep);
/*ICI;_MEDobjetsOuverts(fid);*/
/****************************************************************************
* LECTURE DES ELEMENTS *
* Mailles : *
* - Types geometriques classiques : MED_SEG2, MED_SEG3, MED_TRIA3, ... *
* - Elements de structure *
* - Polygones quelconques. *
* - Polyedres quelconques. *
* Faces (connectivite descendante uniquement) : *
* - Types geometriques classiques. *
* - Polygones quelconques. *
****************************************************************************/
/* lecture et affichage des mailles */
lecture_mailles_standards(fid,nommaa,numdt,numit,mdim,nmailles,mode_coo,typ_con);
/*ICI;_MEDobjetsOuverts(fid);*/
if (lecture_en_tete_seulement == MED_LECTURE_MAILLAGE_SUPPORT_UNIQUEMENT) return;
if (_nmodels>0) {
lecture_mailles_elstruct(fid,nommaa,numdt,numit,_nmodels,
_geotype_elst,_geotypename_elst,_nmailles_elst,mode_coo);
/* Ces desallocations sont effectuées
après la lecture des champs sur ces éléments de structure */
/* free(_nmailles_elst); */
/* free(_geotype_elst); */
/* free(_geotypename_elst); */
}
/*ICI;_MEDobjetsOuverts(fid);*/
if (nmpolygones > 0)
lecture_mailles_polygones(fid,nommaa,numdt,numit,MED_POLYGON,nmpolygones,mode_coo,typ_con);
/*ICI;_MEDobjetsOuverts(fid);*/
if (nmpolygones2 > 0)
lecture_mailles_polygones(fid,nommaa,numdt,numit,MED_POLYGON2,nmpolygones2,mode_coo,typ_con);
/*ICI;_MEDobjetsOuverts(fid);*/
if (npolyedres > 0)
lecture_mailles_polyedres(fid,nommaa,numdt,numit,npolyedres,mode_coo,typ_con);
/*ICI;_MEDobjetsOuverts(fid);*/
/* lecture et affichage des faces en connectivite descendante uniquement */
if (typ_con == MED_DESCENDING) {
lecture_faces_standard(fid,nommaa,numdt,numit,mdim,nfaces,mode_coo);
if (nfpolygones > 0)
lecture_faces_polygones(fid,nommaa,numdt,numit,nfpolygones,mode_coo);
}
/*ICI;_MEDobjetsOuverts(fid);*/
/* lecture et affichage des aretes en connectivite descendante uniquement */
if (typ_con == MED_DESCENDING)
lecture_aretes_standards(fid,nommaa,numdt,numit,mdim,naretes,mode_coo);
/*ICI;_MEDobjetsOuverts(fid);*/
/****************************************************************************
* LECTURE DES FAMILLES *
****************************************************************************/
lecture_famille_maillage(fid,nommaa,nfam);
/*ICI;_MEDobjetsOuverts(fid);*/
/****************************************************************************
* LECTURE DES EQUIVALENCES *
****************************************************************************/
lecture_equivalence_maillage(fid,nommaa,nequ);
/*ICI;_MEDobjetsOuverts(fid);*/
/****************************************************************************
* LECTURE DES JOINTS *
****************************************************************************/
lecture_joint_maillage(fid,nommaa,njnt);
/*ICI;_MEDobjetsOuverts(fid);*/
return;
}
void lecture_caracteristiques_grille(const med_idt fid,
const char * const nommaa,
const med_int numdt,
const med_int numit,
const med_int mdim,
med_int *nind,
med_int *nnoe,
med_int *nmai,
med_grid_type *type)
{
med_err ret = 0;
med_int axe;
med_int *structure_grille;
med_data_type quoi;
med_int j;
med_bool chgt=MED_FALSE,trsf=MED_FALSE;
/* lecture de la nature du maillage structure : MED_GRILLE_CARTESIENNE ,...*/
ret = MEDmeshGridTypeRd(fid,nommaa,type);
EXIT_IF(ret < 0,"a la lecture du type d'une grille ",NULL);
switch(*type) {
case MED_CARTESIAN_GRID :
case MED_POLAR_GRID :
if (*type == MED_CARTESIAN_GRID)
fprintf(stdout,"- Type de grille : MED_GRILLE_CARTESIENNE \n");
else
fprintf(stdout,"- Type de grille : MED_GRILLE_POLAIRE \n");
for (axe=1;axe<=mdim;axe++) {
switch(axe) {
case 1:
quoi = MED_COORDINATE_AXIS1;
break;
case 2:
quoi = MED_COORDINATE_AXIS2;
break;
case 3:
quoi = MED_COORDINATE_AXIS3;
break;
}
nind[axe - 1] = MEDmeshnEntity(fid,nommaa, numdt, numit,
MED_NODE, MED_NONE, quoi, MED_NO_CMODE, &chgt, &trsf);
EXIT_IF(nind[axe - 1] < 0,
"lors de la lecture de la taille d'un indice d'une grille",
NULL);
*nnoe = nind[axe - 1] * (*nnoe);
*nmai = (nind[axe - 1] - 1) * (*nmai);
fprintf(stdout,
"- Taille de l'indice de l'axe " IFORMAT " des coordonnees : " IFORMAT " \n",
axe,nind[axe - 1]);
}
break;
case MED_CURVILINEAR_GRID:
fprintf(stdout,"- Type de grille : MED_GRILLE_DESTRUCTUREE \n");
*nnoe = MEDmeshnEntity(fid, nommaa, numdt, numit,
MED_NODE, MED_NONE, MED_COORDINATE, MED_NO_CMODE, &chgt, &trsf);
EXIT_IF(*nnoe < 0,"lors de la lecture du nombre de noeuds du maillage "
,nommaa);
/* on alloue la memoire */
structure_grille = (med_int *) malloc(sizeof(med_int)*mdim);
EXIT_IF(structure_grille == NULL,NULL,NULL);
/* on lit la structure de la grille
et on affiche le resultat */
ret = MEDmeshGridStructRd(fid,nommaa,numdt, numit, structure_grille);
EXIT_IF(ret < 0,"lors de la lecture de la structure de la grille",
NULL);
fprintf(stdout,"- Structure de la grille : [ ");
for (j=0;j<mdim;j++) {
*nmai = (*(structure_grille+j) - 1) * (*nmai);
fprintf(stdout," " IFORMAT " ",*(structure_grille+j));
}
fprintf(stdout," ] \n");
/* on nettoie la memoire */
free(structure_grille);
break;
case MED_UNDEF_GRID_TYPE:
default:
EXIT_IF(-1,"Type de grille non reconnu.",nommaa);
}
fprintf(stdout,"- Nombre de noeuds : " IFORMAT " \n",*nnoe);
fprintf(stdout,"- Nombre de mailles : " IFORMAT " \n",*nmai);
return;
}
void lecture_noeuds_maillage_structure(const med_idt fid,
const char * const nommaa,
const med_int numdt,
const med_int numit,
const med_int mdim,
const med_int edim,
const med_int * const nind,
const med_int nnoe,
const char * const comp,
const char * const unit,
const med_grid_type type,
const med_switch_mode mode_coo)
{
med_err ret = 0;
med_int axe,i,j;
char str[MED_SNAME_SIZE+1];
med_float *coo = NULL;
med_float *indices = NULL;
med_int *nufano = NULL;
med_int *numnoe = NULL;
char *nomnoe = NULL;
med_bool inufael=MED_FALSE;
fprintf(stdout,"\n(*************************)\n");
fprintf(stdout,"(* NOEUDS DE LA GRILLE : *)\n");
fprintf(stdout,"(*************************)\n");
switch(type) {
case MED_CARTESIAN_GRID :
case MED_POLAR_GRID :
/* on affiche les coordonnees de chacun des axes */
for (axe = 1; axe<=mdim; axe++) {
/* on alloue la memoire */
indices = (med_float *) malloc(sizeof(med_float)*nind[axe - 1]);
EXIT_IF(indices == NULL,NULL,NULL);
/* on lit le tableau des indices de coordonnees
et on affiche le resultat */
ret = MEDmeshGridIndexCoordinateRd(fid,nommaa,numdt,numit, axe,indices);
EXIT_IF(ret < 0,"lors de la lecture d'un tableau d'indice",
NULL);
fprintf(stdout,"\n - Axe %." xstr(MED_SNAME_SIZE) "s [%." xstr(MED_SNAME_SIZE) "s] : [ ",
&comp[MED_SNAME_SIZE*(axe-1)],&unit[MED_SNAME_SIZE*(axe-1)]);
for (j=0;j<nind[axe - 1];j++)
fprintf(stdout," %f ",*(indices+j));
printf(" ] \n");
/* on nettoie la memoire */
free(indices);
}
break;
case MED_CURVILINEAR_GRID:
/* on alloue la memoire */
coo = (med_float *) malloc(sizeof(med_float)*nnoe*edim);
EXIT_IF(coo == NULL,NULL,NULL);
/* on va lire les coordonnees des noeuds */
ret = MEDmeshNodeCoordinateRd(fid,nommaa,numdt,numit, MED_FULL_INTERLACE,coo);
EXIT_IF(ret < 0,"lors de la lecture des noeuds du maillage",NULL);
/* on affiche le resultat */
fprintf(stdout,"- Nom des coordonnees : \n");
for (i=0;i<edim;i++) {
strncpy(str,comp+i*MED_SNAME_SIZE,MED_SNAME_SIZE);
str[MED_SNAME_SIZE] = '\0';
fprintf(stdout," %s ",str);
}
fprintf(stdout,"\n- Unites des coordonnees : \n");
for (i=0;i<edim;i++) {
strncpy(str,unit+i*MED_SNAME_SIZE,MED_SNAME_SIZE);
str[MED_SNAME_SIZE] = '\0';
fprintf(stdout," %s ",str);
}
if (!structure) {
fprintf(stdout,"\n - Coordonnees des noeuds : [ ");
for (j=0;j<nnoe*edim;j++)
fprintf(stdout," %f ",*(coo+j));
fprintf(stdout," ] \n");
}
/* on nettoie la memoire */
free(coo);
break;
case MED_UNDEF_GRID_TYPE:
default:
EXIT_IF(-1,"Type de grille non reconnu.",nommaa);
}
/* lecture et affichage des :
- numeros de familles des noeuds
- noms des noeuds (optionnel)
- numeros des noeuds (optionnel) */
/* on alloue la memoire */
numnoe = (med_int *) malloc(sizeof(med_int)*nnoe);
EXIT_IF(numnoe == NULL,NULL,NULL);
nomnoe = (char*) malloc(MED_SNAME_SIZE*nnoe+1);
EXIT_IF(nomnoe == NULL,NULL,NULL);
nufano = (med_int *) malloc(sizeof(med_int)*nnoe);
EXIT_IF(nufano == NULL,NULL,NULL);
/* on va lire les numeros de familles des noeuds */
ret = MEDmeshEntityFamilyNumberRd(fid,nommaa,numdt,numit,MED_NODE,MED_NO_GEOTYPE,nufano);
if (ret < 0) ret=0; else inufael=MED_TRUE;
EXIT_IF(ret < 0,"lors de la lecture des numeros de familles des noeuds",
NULL);
if (!structure) {
/* on affiche le resultat */
fprintf(stdout,"\n- Numeros des familles des noeuds : \n");
for (i=0;i<nnoe;i++)
if (inufael)
fprintf(stdout," " IFORMAT " ",*(nufano+i));
else
fprintf(stdout," %d ",0);
fprintf(stdout,"\n");
}
/* on va lire et afficher les noms des noeuds */
if (MEDmeshEntityNameRd(fid,nommaa,numdt,numit,MED_NODE,MED_NO_GEOTYPE,nomnoe) == 0) {
if (!structure) {
fprintf(stdout,"\n- Noms des noeuds : \n");
for (i=0;i<nnoe;i++) {
strncpy(str,nomnoe+i*MED_SNAME_SIZE,MED_SNAME_SIZE);
str[MED_SNAME_SIZE] = '\0';
fprintf(stdout," %s ",str);
}
}
}
/* on va lire et afficher les numeros des noeuds */
if (MEDmeshEntityNumberRd(fid,nommaa,numdt,numit,MED_NODE,MED_NO_GEOTYPE,numnoe) == 0) {
if (!structure) {
fprintf(stdout,"\n- Numeros des noeuds : \n");
for (i=0;i<nnoe;i++)
fprintf(stdout," " IFORMAT " ",*(numnoe+i));
}
}
/* on nettoie la memoire */
free(nufano);
free(numnoe);
free(nomnoe);
return;
}
void lecture_mailles_maillage_structure(const med_idt fid,
const char * const nommaa,
const med_int numdt,
const med_int numit,
const med_int mdim,
const med_int nmai)
{
med_err ret = 0;
med_int i;
med_int *nufael = NULL;
char *nomele = NULL;
med_int *numele = NULL;
char str[MED_SNAME_SIZE+1];
/* type geometrique des elements */
med_geometry_type typgeo;
fprintf(stdout,"\n(***************************)\n");
fprintf(stdout,"(* ELEMENTS DE LA GRILLE : *)\n");
fprintf(stdout,"(***************************)\n");
/* type des mailles */
switch(mdim) {
case 0 :
typgeo = MED_POINT1;
break;
case 1 :
typgeo = MED_SEG2;
break;
case 2 :
typgeo = MED_QUAD4;
break;
default :
typgeo = MED_HEXA8;
}
/* On va lire et afficher :
* - Les numeros de familles
* - Les noms (optionnel)
* - Les numeros (optionnel)
*/
/* on alloue la memoire */
numele = (med_int *) malloc(sizeof(med_int)*nmai);
EXIT_IF(numele == NULL,NULL,NULL);
nomele = (char *) malloc(sizeof(char)*MED_SNAME_SIZE*nmai+1);
EXIT_IF(nomele == NULL,NULL,NULL);
nufael = (med_int *) malloc(sizeof(med_int)*nmai);
EXIT_IF(nufael == NULL,NULL,NULL);
/* lecture des numeros de famille */
ret = MEDmeshEntityFamilyNumberRd(fid,nommaa,numdt,numit,MED_CELL,typgeo,nufael);
if (ret < 0)
for (i=0;i<nmai;i++)
*(nufael+i) = 0;
if (!structure) {
/* on affiche le resultat */
fprintf(stdout,"\n- Numeros des familles des mailles : \n");
for (i=0;i<nmai;i++)
fprintf(stdout," " IFORMAT " ",*(nufael+i));
fprintf(stdout,"\n");
}
/* on va lire et afficher les noms des mailles */
if (MEDmeshEntityNameRd(fid,nommaa,numdt,numit,MED_CELL,typgeo,nomele) == 0) {
if (!structure) {
fprintf(stdout,"\n - Noms : \n");
for (i=0;i<nmai;i++) {
strncpy(str,nomele+i*MED_SNAME_SIZE,MED_SNAME_SIZE);
str[MED_SNAME_SIZE] = '\0';
fprintf(stdout," %s ",str);
}
}
}
/* on va lire et afficher les numeros des mailles */
if (MEDmeshEntityNumberRd(fid,nommaa,numdt,numit,MED_CELL,typgeo,numele) == 0) {
if (!structure) {
fprintf(stdout,"\n - Numeros :\n");
for (i=0;i<nmai;i++)
fprintf(stdout," " IFORMAT " ",*(numele+i));
}
}
/* on libere la memoire */
free(nufael);
free(nomele);
free(numele);
return;
}
void lecture_maillage_structure(const med_idt fid,
const char * const nommaa,
const med_int numdt,
const med_int numit,
const med_int mdim,
const med_int edim,
const med_switch_mode mode_coo,
const char * const comp,
const char * const unit,
const int lecture_en_tete_seulement)
{
/* nombre de valeurs selon les axes du repere */
med_int nind[3];
med_int nnoe = 1;
med_int nmai = 1;
/* type de la grille */
med_grid_type type;
/* nombre de familles */
med_int nfam;
/* nombre d'equivalences */
med_int nequ;
/* nombre de joints */
med_int njnt;
/* lecture selon la nature de la grille des caracteristiques
du maillage :
- nombre de noeuds
- nombre de mailles
*/
lecture_caracteristiques_grille(fid,nommaa,numdt,numit,mdim,nind,&nnoe,&nmai,&type);
/* nombre de familles */
nfam = lecture_nombre_famille(fid,nommaa);
/* nombre d'equivalences */
nequ = lecture_nombre_equivalence(fid,nommaa);
/* combien de joints */
njnt = lecture_nombre_joint(fid,nommaa);
if (lecture_en_tete_seulement)
return ;
/****************************************************************************
* LECTURE DES NOEUDS *
****************************************************************************/
lecture_noeuds_maillage_structure(fid,nommaa,numdt,numit,mdim,edim,nind,nnoe,comp,unit,type,mode_coo);
/****************************************************************************
* LECTURE DES ELEMENTS *
****************************************************************************/
lecture_mailles_maillage_structure(fid,nommaa,numdt,numit,mdim,nmai);
/****************************************************************************
* LECTURE DES FAMILLES *
****************************************************************************/
lecture_famille_maillage(fid,nommaa,nfam);
/****************************************************************************
* LECTURE DES EQUIVALENCES *
****************************************************************************/
lecture_equivalence_maillage(fid,nommaa,nequ);
/****************************************************************************
* LECTURE DES JOINTS *
****************************************************************************/
lecture_joint_maillage(fid,nommaa,njnt);
return ;
}
med_err getFieldsOn(const med_idt fid,
const char * const maillage,
const med_int mnumdt,
const med_int mnumit,
const med_int nmodels,
const med_geometry_type* const geotype_elst,
const char* const geotypename_elst,
const char * const nomcha,
const char * const dtunit,
const med_field_type typcha,
const med_int ncomp,
const char * const comp,
const char * const unit,
const med_entity_type entite,
const med_switch_mode stockage,
const med_int ncstp) {
int i,j,k,l,m,n,nb_geo=0;
med_int nbpdtnor=0,pflsize,*pflval,ngauss=0,ngroup,nval;
unsigned char *val = NULL;
med_int numdt=0,numo=0,_nprofile;
med_int meshnumdt=0,meshnumit=0;
med_size medtype_size=0;
med_float dt=0.0;
med_err ret=0;
char pflname [MED_NAME_SIZE+1]="";
char locname [MED_NAME_SIZE+1]="";
char meshname [MED_NAME_SIZE+1]="";
char maa_ass [MED_NAME_SIZE+1]="";
char * lien = NULL;
med_bool localmesh;
med_int nmesh=0;
med_int lnsize=0;
med_geometry_type * type_geo;
med_geometry_type * _lgeotype=MED_NULL;
med_int _ngeo=0;
med_int _usedgeobyncs=0;
char * * AFF_lgeotype = NULL;
size_t _bannerlen=255;
size_t _bannerlen1=0,_bannershift1=0;
char _temp1[MAXBANNERLEN+1]="";
char * _bannerstr1=NULL;
size_t _bannerlen2=0,_bannershift2=0;
char _temp2[MAXBANNERLEN+1]="";
char * _bannerstr2=NULL;
const char * const * AFF;
const char * const * AFF_ENT=MED23FIELD_GET_ENTITY_TYPENAME+1;
const char * * AFF_STRUCT = NULL;
switch (entite) {
case MED_NODE :
type_geo = MED23FIELD_GET_NODE_GEOMETRY_TYPE;
nb_geo = MED_N_NODE_FIXED_GEO;
AFF = MED23FIELD_GET_NODE_GEOMETRY_TYPENAME;
break;
case MED_CELL :
case MED_NODE_ELEMENT :
type_geo = MED23FIELD_GET_CELL_GEOMETRY_TYPE;
nb_geo = MED_N_CELL_FIXED_GEO;
AFF = MED23FIELD_GET_CELL_GEOMETRY_TYPENAME;
break;
case MED_DESCENDING_FACE :
type_geo = MED23FIELD_GET_FACE_GEOMETRY_TYPE;
nb_geo = MED_N_FACE_FIXED_GEO;
AFF = MED23FIELD_GET_FACE_GEOMETRY_TYPENAME;
break;
case MED_DESCENDING_EDGE :
type_geo = MED23FIELD_GET_EDGE_GEOMETRY_TYPE;
nb_geo = MED_N_EDGE_FIXED_GEO;
AFF = MED23FIELD_GET_EDGE_GEOMETRY_TYPENAME;
break;
case MED_STRUCT_ELEMENT :
AFF_STRUCT = (const char * *) calloc(sizeof(const char * ),nmodels+1);
for(i=0;i<nmodels;++i) AFF_STRUCT[i+1]= &geotypename_elst[(MED_NAME_SIZE+1)*i];
type_geo = (med_geometry_type*)(geotype_elst)-1;
nb_geo = nmodels;
AFF = AFF_STRUCT;
break;
}
/*On itère sur les types géométriques ds la boucle externe à cause de la compatibilité 23 :
En V2.3.6 :
/CHA/<fieldname>/<entitytype>[.<geotype>]/" ....<numdt> ...<numit>"/<meshname>/MED_NOM_CO
{MED_NOM_TYP, {MED_NOM_NDT,MED_NOM_PDT, {MED_NOM_NBR,
MED_NOM_NCO MED_NOM_NOR,MED_NOM_MAI MED_NOM_PFL,
MED_NOM_NOM, MED_NOM_UNI} MED_NOM_GAU,
MED_NOM_UNI} MED_NOM_NGA}
V3.0 :
/CHA/<fieldname>/" ....<numdt> ...<numit>"/<entitytype>[.<geotype>]/<pflname>/MED_NOM_CO
{MED_NOM_TYP, {MED_NOM_PDT, {MED_NOM_PFL(2), {MED_NOM_NBR(1),
MED_NOM_MAI, MED_NOM_NDT,MED_NOM_NOR, MED_NOM_GAUSS(2)} MED_NOM_GAU(2),
MED_NOM_NCO, MED_NOM_RDT,MED_NOM_ROR} MED_NOM_NGA}
MED_NOM_NOM,
MED_NOM_UNI,
MED_NOM_UNT}
*/
/*
TODO : Versionner getFieldsOn en 3.0 pour rendre l'algorithme plus efficace en fonction de la version de fichier lu.
*/
_ngeo=MEDfieldnGeometryType(fid,nomcha,MED_ALL_DT,MED_ALL_IT,entite);
/* ISCRUTE(_ngeo); */
_lgeotype=calloc(_ngeo+1,sizeof(med_geometry_type));_lgeotype[0]=MED_NO_GEOTYPE;
MEDfieldGeometryType(fid,nomcha,MED_ALL_DT,MED_ALL_IT,entite,&_lgeotype[1],&_usedgeobyncs);
type_geo = _lgeotype;
AFF_lgeotype = ( char * *) calloc(_ngeo+1,sizeof(char * ));AFF_lgeotype[0]=MED_NULL;
for(i=1;i<=_ngeo;++i) {
AFF_lgeotype[i]=calloc(MED_NAME_SIZE+1,sizeof(char));
MEDmeshGeotypeName(fid,_lgeotype[i],AFF_lgeotype[i]);
}
AFF = (const char * *) AFF_lgeotype;
/* for (k=1;k<=nb_geo;k++) { */
for (k=1;k<=_ngeo;k++) {
/* Combien de (PDT,NOR) a lire */
nbpdtnor = ncstp;
if (nbpdtnor < 1 ) continue;
for (j=0;j<nbpdtnor;j++) {
if ( MEDfield23ComputingStepMeshInfo(fid, nomcha,j+1, &numdt, &numo, &dt,
&nmesh, maa_ass, &localmesh, &meshnumdt, &meshnumit ) <0) {
MESSAGE("Erreur a la demande d'information sur (pdt,nor) : ");
ISCRUTE(numdt); ISCRUTE(numo);ISCRUTE(nmesh);SSCRUTE(meshname);ISCRUTE_int(localmesh);
ISCRUTE(meshnumdt);ISCRUTE(meshnumit);
ret = -1; continue;
}
for (i=0;i< nmesh;++i) {
if ( (_nprofile = MEDfield23nProfile(fid,nomcha,numdt,numo,entite,type_geo[k],i+1,
meshname,pflname,locname ) ) < 0 ) {
MESSAGE("Erreur a la demande du nombre de profils referencés par le champ : ");
SSCRUTE(nomcha); ISCRUTE(numdt); ISCRUTE(numo);SSCRUTE(meshname);
ISCRUTE_int(entite);ISCRUTE_int(type_geo[k]);SSCRUTE(pflname);SSCRUTE(locname);
SSCRUTE(AFF_ENT[(int)entite]);SSCRUTE(AFF[k]);
ret = -1; continue;
};
for (l=0;l<_nprofile;l++) {
if ( (nval = MEDfield23nValueWithProfile(fid, nomcha, numdt, numo, entite, type_geo[k],meshname,
l+1, USER_MODE, pflname,&pflsize,
locname, &ngauss) ) < 0 ) {
MESSAGE("Erreur a la lecture du nombre de valeurs du champ : ");
SSCRUTE(nomcha);ISCRUTE(numdt);ISCRUTE(numo);SSCRUTE(meshname);
ISCRUTE_int(entite);ISCRUTE_int(type_geo[k]);
ISCRUTE_int(USER_MODE);
ret = -1; continue;
};
/* Affiche uniquement les informations du champ pour le maillage demandé <maillage,numit,nmumdt>
Si le maillage demandé n'est pas précisé maillage == "", affiche les informations du champ
pour tous les maillages */
if ( ( (!strcmp(meshname,maillage)) && (meshnumdt == mnumdt) && (meshnumit == mnumit)) ||
( !strlen(maillage) )
) {
/*4 caractères spéciaux*/
_bannerstr1 = "(* CHAMP |%s| A L'ÉTAPE DE CALCUL (n°dt,n°it)="
"(% 2.2" MED_IFORMAT ",% 2.2" MED_IFORMAT ") , %.*s*)\n";
/*4 caractères spéciaux */
_bannerstr2 = "(* SUR LE MAILLAGE |%s| A L'ÉTAPE DE CALCUL (n°dt,n°it)="
"(% 2.2" MED_IFORMAT ",% 2.2" MED_IFORMAT ") : %.*s*)\n";
snprintf(_temp1,MAXBANNERLEN+1,_bannerstr1,nomcha,numdt,numo,0,"");
snprintf(_temp2,MAXBANNERLEN+1,_bannerstr2,meshname,meshnumdt,meshnumit,0,"");
_bannerlen1 = strlen(_temp1);
_bannerlen2 = strlen(_temp2);
_bannerlen=MAX(_bannerlen1,_bannerlen2);
if (_bannerlen1>_bannerlen2) {
_bannershift1 = 0; _bannershift2 = _bannerlen1-_bannerlen2;
} else {
_bannershift2 = 0; _bannershift1 = _bannerlen2-_bannerlen1;
}
fprintf(stdout,"\n(");
for (i=0;i< _bannerlen-6; i++) fprintf(stdout,"*");
fprintf(stdout,")\n");
fprintf(stdout,_bannerstr1,nomcha,numdt,numo,_bannershift1,MED_NAME_BLANK);
fprintf(stdout,_bannerstr2,meshname,meshnumdt,meshnumit,_bannershift2,MED_NAME_BLANK);
fprintf(stdout,"(");
for (i=0;i< _bannerlen-6; i++) fprintf(stdout,"*");
fprintf(stdout,")\n");
/* fprintf(stdout,"\n(********************************************************************************)\n"); */
/* fprintf(stdout,"(* CHAMP |%s| A L'ÉTAPE DE CALCUL (n°dt,n°it)=" */
/* "(% 2.2"MED_IFORMAT",% 2.2"MED_IFORMAT") : *)\n", */
/* nomcha,numdt,numo); */
/* fprintf(stdout,"(* SUR LE MAILLAGE |%s| A L'ÉTAPE DE CALCUL (n°dt,n°it)=" */
/* "(% 2.2"MED_IFORMAT",% 2.2"MED_IFORMAT") : *)\n", */
/* meshname,meshnumdt,meshnumit); */
/* fprintf(stdout,"(********************************************************************************)\n\n"); */
fprintf(stdout,"- Valeur de la date du champ %f [%s] : \n",dt,dtunit);
fprintf(stdout,"- Type des composantes du champ : %d\n",typcha);
fprintf(stdout,"- Nombre de composantes par valeur : " IFORMAT "\n",ncomp);
fprintf(stdout,"- Unité des composantes : |%s|\n",unit);
fprintf(stdout,"- Nom des composantes : |%s|\n",comp);
printf("\t- Il y a " IFORMAT " entités qui portent des valeurs en mode %i."
"\n\t Chaque entite %s de type geometrique %s associes au profil |%s| a " IFORMAT " point(s) d'intégration \n",
nval,USER_MODE,AFF_ENT[(int)entite],AFF[k],pflname,ngauss);
/* Le maillage reference est-il porte par un autre fichier */
if ( !localmesh ) {
if ( (lnsize=MEDlinkInfoByName(fid,maa_ass) ) < 0 ) {
MESSAGE("Erreur a la lecture de la taille du lien : ");
SSCRUTE(maa_ass);
ret = -1;
} else {
lien = (char *)malloc(lnsize*sizeof(char) + 1);
EXIT_IF(lien == NULL,NULL,NULL);
if ( MEDlinkRd(fid, maa_ass, lien) < 0 ) {
MESSAGE("Erreur a la lecture du lien : ");
SSCRUTE(maa_ass);SSCRUTE(lien);
ret = -1;
} else {
lien[lnsize] = '\0';
printf("\tLe maillage |%s| est porte par un fichier distant |%s|\n",maa_ass,lien);
}
free(lien);
}
}
/*Lecture des valeurs du champ */
switch(typcha) {
case MED_FLOAT64: medtype_size=sizeof(med_float64); break;
case MED_FLOAT32: medtype_size=sizeof(med_float32); break;
case MED_INT32 : medtype_size=sizeof(med_int32 ); break;
case MED_INT64 : medtype_size=sizeof(med_int64 ); break;
case MED_INT : medtype_size=sizeof(med_int) ; break;
default:
MESSAGE("Erreur a la lecture du type de champ : ");
ISCRUTE_int(typcha);
EXIT_IF(NULL == NULL,NULL,NULL);
}
val = (unsigned char*) calloc(ncomp*nval*ngauss,medtype_size);
EXIT_IF(val == NULL,NULL,NULL);
if (MEDfield23ValueWithProfileRd(fid, nomcha, numdt,numo, entite,type_geo[k],meshname,
USER_MODE, pflname, stockage,MED_ALL_CONSTITUENT,
(unsigned char*) val) < 0 ) {
MESSAGE("Erreur a la lecture des valeurs du champ : ");
SSCRUTE(nomcha);ISCRUTE_int(entite);ISCRUTE_int(type_geo[k]);
ISCRUTE(numdt);ISCRUTE(numo);
ret = -1;
}
if ( strlen(locname) && (_nprofile > 1) )
printf("\t- Modèle de localisation des points de Gauss de nom |%s|\n",locname);
if (entite == MED_NODE_ELEMENT)
ngroup = (type_geo[k] % 100);
else
ngroup = ngauss;
switch (stockage) {
case MED_FULL_INTERLACE :
if (!structure) {
printf("\t- Valeurs :\n\t");
for (m=0;m<(nval*ngauss)/ngroup;m++) {
printf("|");
for (n=0;n<ngroup*ncomp;n++)
switch(typcha) {
case MED_FLOAT64:
printf(" %f ",*(((med_double*)val)+(m*ngroup*ncomp)+n ) );
/* printf(" %f ", ((med_double*)val)[(m*ngroup*ncomp)+n] ); */
/* printf(" %f ", *( val+medtype_size*((m*ngroup*ncomp)+n)) ); */
break;
case MED_FLOAT32:
printf(" %f ",*(((med_float32*)val)+((m*ngroup*ncomp)+n)));
break;
case MED_INT32 :
printf(" %d ",*(((med_int32*)val)+(m*ngroup*ncomp)+n));
break;
case MED_INT64 :
printf(" %ld ",*(((med_int64*)val)+(m*ngroup*ncomp)+n));
break;
case MED_INT :
printf(" " IFORMAT " ",*(((med_int*)val)+(m*ngroup*ncomp)+n));
break;
default:
break;
}
}
}
break;
/*??? Affichage en fonction du profil à traiter ???*/
case MED_NO_INTERLACE :
if (!structure) {
printf("\t- Valeurs :\n\t");
for (m=0;m<ncomp;m++) {
printf("|");
for (n=0;n<(nval*ngauss);n++)
switch(typcha) {
case MED_FLOAT64:
printf(" %f ",*(((med_double*)val)+(m*nval*ngauss)+n ) );
/* printf(" %f ", ((med_double*)val)[(m*nval)+n] ); */
/* printf(" %f ", *( val+medtype_size*((m*nval)+n)) ); */
break;
case MED_FLOAT32:
printf(" %f ",*(((med_float32*)val)+((m*nval*ngauss)+n)));
break;
case MED_INT32 :
printf(" %d ",*(((med_int32*)val)+(m*nval*ngauss)+n));
break;
case MED_INT64 :
printf(" %ld ",*(((med_int64*)val)+(m*nval*ngauss)+n));
break;
case MED_INT :
printf(" " IFORMAT " ",*(((med_int*)val)+(m*nval*ngauss)+n));
break;
default:
break;
}
}
}
break;
}
if (!structure) {
printf("|\n");
}
if ( val ) {free(val);val = NULL;}
/*Lecture du profil associe */
if (strcmp(pflname,MED_NO_PROFILE) == 0 ) {
printf("\t- Profil : MED_NOPFL\n");
} else {
if ( (pflsize = MEDprofileSizeByName(fid,pflname)) <0 ) {
MESSAGE("Erreur a la lecture du nombre de valeurs du profil : ");
SSCRUTE(pflname);
ret = -1; continue;
}
printf("\t- Profil : |%s| de taille " IFORMAT "\n",pflname,pflsize);
pflval = (med_int*) malloc(sizeof(med_int)*pflsize);
EXIT_IF(pflval == NULL,NULL,NULL);
if ( MEDprofileRd(fid,pflname,pflval) <0) {
MESSAGE("Erreur a la lecture des valeurs du profil : ");
SSCRUTE(pflname);
ret = -1;
}
if (!structure) {
printf("\t");
for (m=0;m<pflsize;m++) printf(" " IFORMAT " ",*(pflval+m));
printf("\n");
}
free(pflval);
}
}
}
}
}
} /* fin for sur les mailles*/
for(i=1;i<=_ngeo;++i) free(AFF_lgeotype[i]);
free(AFF_lgeotype);
free(_lgeotype);
free(AFF_STRUCT);
return ret;
}
/******************************************************************************
*
* - Nom de la fonction : lecture_resultats
* - Description : lecture et affichage des champs de resultats
* associe a un maillage MED.
* - Parametres :
* - fid (IN) : ID du fichier MED.
* - maillage (IN) : nom du maillage maillage.
* - mode_coo (IN) : mode de stockage en memoire :
* MED_FULL_INTERLACE |
* MED_NO_INTERLACE.
* - lecture_en_tete_seulement (IN) : mode de lecture.
******************************************************************************/
void lecture_resultats(const med_idt fid,
const char * const maillage,
const med_int mnumdt,
const med_int mnumit,
const med_switch_mode mode_coo,
const med_int nmodels,
const med_geometry_type* geotype_elst,
const char* geotypename_elst,
const int lecture_en_tete_seulement)
{
med_err ret,lret;
char *comp, *unit;
char nomcha [MED_NAME_SIZE+1]="";
med_int ncomp,ncha;
med_field_type typcha;
int i,j;
char nommaa[MED_NAME_SIZE+1]="";
med_bool localmaa = MED_FALSE;
char dtunit[MED_SNAME_SIZE+1]="";
med_int ncstp=0,_nentity=0;
med_entity_type * _lentitytype =NULL;
med_int _usedbyncs = 0;
/* combien de champs dans le fichier */
ncha = MEDnField(fid);
EXIT_IF(ncha < 0,"lors de la lecture du nombre de champs",NULL);
if ( !strlen(maillage) || lecture_en_tete_seulement ) {
fprintf(stdout,"\n(************************)\n");
fprintf(stdout,"(* CHAMPS RESULTATS : *)\n");
fprintf(stdout,"(************************)\n");
fprintf(stdout,"- Nombre de champs : " IFORMAT " \n",ncha);
}
/****************************************************************************
* LECTURE DES CHAMPS *
****************************************************************************/
ret = 0;
/* lecture de tous les champs pour le maillage selectionne */
for (i =0;i<ncha;i++) {
lret = 0;
/* Lecture du nombre de composantes */
if ((ncomp = MEDfieldnComponent(fid,i+1)) < 0) {
MESSAGE("Erreur à la lecture du nombre de composantes : ");
ISCRUTE(ncomp);
ret = -1; continue;
}
/* Lecture du type du champ, des noms des composantes et du nom de
l'unité*/
comp = (char*) malloc(ncomp*MED_SNAME_SIZE+1);
EXIT_IF(comp == NULL,NULL,NULL);
unit = (char*) malloc(ncomp*MED_SNAME_SIZE+1);
EXIT_IF(unit == NULL,NULL,NULL);
if ( MEDfieldInfo(fid, i+1, nomcha, nommaa, &localmaa,
&typcha, comp, unit, dtunit, &ncstp) < 0 ) {
MESSAGE("Erreur à la demande d'information sur les champs : ");
ret = -1; continue;
}
if ( !strlen(maillage) || lecture_en_tete_seulement ) {
printf("\nChamp numero : |%d| \n",i+1);
printf("Nom du champ : |%s| de type |%d|\n",nomcha,typcha);
printf("Nom des composantes : |%s|\n",comp);
printf("Unites des composantes : |%s| \n",unit);
if (strlen(dtunit))
printf("Unité des dates : |%s|\n",dtunit);
if ( ncstp > 1 )
printf("Nombre d'étapes de calcul : |" IFORMAT "| \n",ncstp);
}
if (lecture_en_tete_seulement) {
free(comp);
free(unit);
continue;
}
_nentity = MEDfieldnEntityType(fid,nomcha,MED_ALL_DT,MED_ALL_IT);
/*ISCRUTE(MEDfieldnEntityType(fid,nomcha,MED_ALL_DT,MED_ALL_IT)); */
_lentitytype = calloc(_nentity,sizeof(med_entity_type));
MEDfieldEntityType(fid,nomcha,MED_ALL_DT,MED_ALL_IT,_lentitytype,&_usedbyncs);
/* ISCRUTE(__usedbyncs); */
for (j=0; j < _nentity ; j++) {
if (lret == 0)
lret = getFieldsOn(fid, maillage, mnumdt, mnumit, nmodels,geotype_elst,geotypename_elst,
nomcha, dtunit, typcha, ncomp, comp, unit,_lentitytype[j],mode_coo, ncstp);
if (lret != 0) {
MESSAGE("Erreur a la lecture des champs sur entités : ");SSCRUTE(MEDgetEntityTypeName(_lentitytype[j]));
ret = -1;
};
}
free(_lentitytype);
/* champs aux noeuds */
/* lret = getFieldsOn(fid, maillage, mnumdt, mnumit, nmodels,geotype_elst,geotypename_elst, */
/* nomcha, dtunit, typcha, ncomp, comp, unit, MED_NODE,mode_coo, ncstp); */
/* /\* champs sur les elements et aux points de Gauss *\/ */
/* if (lret == 0) lret = getFieldsOn(fid, maillage, mnumdt, mnumit , nmodels,geotype_elst,geotypename_elst, */
/* nomcha, dtunit, typcha, ncomp, comp, unit, MED_CELL,mode_coo, ncstp); */
/* else { MESSAGE("Erreur à la lecture des champs aux noeuds "); ret = -1; continue;} */
/* if (lret == 0) lret = getFieldsOn(fid, maillage, mnumdt, mnumit , nmodels,geotype_elst,geotypename_elst, */
/* nomcha, dtunit, typcha, ncomp, comp, unit, MED_DESCENDING_FACE,mode_coo, ncstp); */
/* else { MESSAGE("Erreur à la lecture des champs aux mailles "); ret = -1; continue;} */
/* if (lret == 0) lret = getFieldsOn(fid, maillage, mnumdt, mnumit , nmodels,geotype_elst,geotypename_elst, */
/* nomcha, dtunit, typcha, ncomp, comp, unit, MED_DESCENDING_EDGE,mode_coo, ncstp); */
/* else {MESSAGE("Erreur à la lecture des champs aux faces "); ret = -1; continue;} */
/* if (lret == 0) lret = getFieldsOn(fid, maillage, mnumdt, mnumit , nmodels,geotype_elst,geotypename_elst, */
/* nomcha, dtunit, typcha, ncomp, comp, unit, MED_NODE_ELEMENT,mode_coo, ncstp); */
/* else {MESSAGE("Erreur a la lecture des champs aux aretes "); ret = -1; continue;} */
/* if (lret != 0) {MESSAGE("Erreur a la lecture des champs aux noeuds des mailles "); ret = -1;}; */
/* if (nmodels) */
/* lret = getFieldsOn(fid, maillage, mnumdt, mnumit , nmodels, geotype_elst,geotypename_elst, */
/* nomcha, dtunit, typcha, ncomp, comp, unit, MED_STRUCT_ELEMENT,mode_coo, ncstp); */
/* if (lret != 0) {MESSAGE("Erreur a la lecture des champs aux éléments de sructure "); ret = -1;}; */
free(comp);
free(unit);
}
return;
}
/******************************************************************************
*
* - Nom de la fonction : lecture_parametres_scalaires
* - Description : lecture des parametres scalaires definis
* hors champs et maillages.
* - Parametres :
* - fid (IN) : ID du fichier MED.
* - lecture_en_tete_seule (IN) : mode de lecture.
*
******************************************************************************/
void lecture_parametres_scalaires(med_idt fid,
int lecture_en_tete_seulement)
{
med_err ret = 0;
char nom_scalaire[MED_NAME_SIZE+1];
char description[MED_COMMENT_SIZE+1];
med_int vali;
med_float valr;
med_int i,n,npdt,j;
med_parameter_type type;
med_int numdt,numo;
med_float dt;
char dt_unit[MED_SNAME_SIZE+1];
/* Combien de variables scalaire ? */
n = MEDnParameter(fid);
EXIT_IF(n < 0,"lors de la lecture du nombre de scalaires",NULL);
if (n) {
fprintf(stdout,"\n(*******************************)\n");
fprintf(stdout,"(* VARIABLES SCALAIRES : *)\n");
fprintf(stdout,"(*******************************)\n\n");
fprintf(stdout,"- Nombre de variables scalaires : " IFORMAT "\n",n);
}
if (lecture_en_tete_seulement)
return ;
for (i=1;i<=n;i++) {
/* Lecture des infos (type,description) */
ret = MEDparameterInfo( fid,i,nom_scalaire,&type,description,
dt_unit, &npdt );
EXIT_IF(ret < 0,"lors de la lecture des parametres d'un scalaire",NULL);
fprintf(stdout,"- Scalaire n°" IFORMAT " de nom %s \n",i,nom_scalaire);
if (type == MED_FLOAT64)
fprintf(stdout," Type flottant. \n");
else
fprintf(stdout," Type entier. \n");
printf(" Description associee : [%s] \n",description);
/* Pour chaque scalaire on regarde les valeurs associees
eventuellement a des pas de temps et des numeros d'ordre */
EXIT_IF(npdt < 0,
"lors de la lecture du nombre de pas de temps d'un scalaire"
,NULL);
fprintf(stdout," Nombre de valeurs stockees : " IFORMAT " \n",npdt);
for (j=1;j<=npdt;j++) {
ret = MEDparameterComputationStepInfo(fid,nom_scalaire,j, &numdt,&numo,&dt);
EXIT_IF(ret < 0,
"lors de la lecture des parametres d'un pas de temps d'un scalaire",
NULL);
if (numdt == MED_NO_DT)
fprintf(stdout," - Aucun de pas de temps \n");
else
fprintf(stdout,
" - Pas de de temps de numero " IFORMAT " de valeur %f [%s] \n",numdt,
dt,dt_unit);
if (numo == MED_NO_IT)
fprintf(stdout," - Aucun numero d'ordre \n");
else
fprintf(stdout," - Numero d'ordre : " IFORMAT " \n",numo);
if (type == MED_FLOAT64) {
ret = MEDparameterValueRd(fid,nom_scalaire,numdt,numo,(unsigned char * ) &valr);
fprintf(stdout," - Valeur : %f \n",valr);
}
else {
ret = MEDparameterValueRd(fid,nom_scalaire,numdt,numo,(unsigned char * ) &vali);
fprintf(stdout," - Valeur : " IFORMAT " \n",vali);
}
EXIT_IF(ret < 0,"lors de la lecture de la valeur d'un scalaire",NULL);
}
}
return ;
}
/******************************************************************************
*
* - Nom de la fonction : lecture_profils
* - Description : lecture des différents profils
* hors champs et maillages.
* - Parametres :
* - fid (IN) : ID du fichier MED.
* - lecture_en_tete_seule (IN) : mode de lecture.
*
******************************************************************************/
void lecture_profils(med_idt fid,
int lecture_en_tete_seulement)
{
med_err ret;
char pflname[MED_NAME_SIZE+1]="";
med_int npro,*pflval,nval;
int i,j;
/* Interrogation des profils */
npro = MEDnProfile(fid);
EXIT_IF(npro < 0,"lors de la lecture du nombre de profils",NULL);
if (npro) {
fprintf(stdout,"\n(*************)\n");
fprintf(stdout, "(* PROFILS : *)\n");
fprintf(stdout, "(*************)\n");
printf("\nNombre de profils stockes : " IFORMAT "\n\n",npro);
}
for (i=1 ; i <= npro ; i++ ) {
if ( MEDprofileInfo(fid, i, pflname, &nval) < 0) {
MESSAGE("Erreur a la demande d'information sur le profil n° : "); ISCRUTE_int(i);
ret = -1;continue;
}
printf("\t- Profil n°%i de nom |%s| et de taille " IFORMAT "\n",i,pflname,nval);
pflval = (med_int*) malloc(sizeof(med_int)*nval);
if ( MEDprofileRd(fid, pflname, pflval) < 0) {
MESSAGE("Erreur a la lecture des valeurs du profil : ");
SSCRUTE(pflname);
ret = -1;
} else {
if (!structure) {
printf("\t");
for (j=0;j<nval;j++) printf(" " IFORMAT " ",*(pflval+j));
}
printf("\n\n");
}
free(pflval);
}
return;
}
/******************************************************************************
*
* - Nom de la fonction : lecture_modeles_elstruct
* - Description : lecture des différents modèles d'éléments de structure
* hors champs et maillages.
* - Parametres :
* - fid (IN) : ID du fichier MED.
* - lecture_en_tete_seule (IN) : mode de lecture.
*
******************************************************************************/
void lecture_modeles_elstruct(med_idt fid,
int lecture_en_tete_seulement)
{
med_err _ret=0;
int _i =0,_j=0,_k=0, _n=0,_nvalue=0;
med_int _nstructelement=0;
med_geometry_type _geotype=MED_NONE;
char _elementname[MED_NAME_SIZE+1]="";
med_int _elementdim=0;
char _supportmeshname[MED_NAME_SIZE+1]="";
med_entity_type _entitytype=MED_UNDEF_ENTITY_TYPE;
med_int _nnode=0;
med_int _ncell=0;
med_geometry_type _geocelltype=MED_NONE;
char _geocelltypename[MED_SNAME_SIZE+1]="";
med_int _nconstantattribute=0;
med_bool _anyprofile=MED_FALSE;
med_int _nvariableattribute=0;
char _constattname[MED_NAME_SIZE+1]="";
med_attribute_type _constatttype=MED_ATT_UNDEF;
char _varattname[MED_NAME_SIZE+1]="";
med_attribute_type _varatttype=MED_ATT_UNDEF;
med_int _ncomponent=0;
med_entity_type _attentitytype=MED_UNDEF_ENTITY_TYPE;
char _profilename[MED_NAME_SIZE+1]="";
med_int _profilesize=0;
unsigned char * _value=NULL;
void (*_printf)(const void*);
med_int _atttypesize=0;
_nstructelement = MEDnStructElement(fid);
EXIT_IF(_nstructelement < 0,"lors de la lecture du nombre d'éléments de structure",NULL);
if(_nstructelement) {
fprintf(stdout,"\n(*************************************)\n");
fprintf(stdout, "(* MODELES D'ELEMENTS DE STRUCTURE : *)\n");
fprintf(stdout, "(*************************************)\n");
printf("\nNombre d'éléments de structure : " IFORMAT "\n\n",_nstructelement);
}
for ( _i=1; _i<= _nstructelement; ++_i) {
_ret= MEDstructElementInfo(fid,_i,_elementname,&_geotype,&_elementdim,_supportmeshname,
&_entitytype,&_nnode,&_ncell,&_geocelltype,&_nconstantattribute,&_anyprofile,
&_nvariableattribute );
EXIT_IF(_ret < 0,"lors de la demande d'information sur les éléments de structure",NULL);
fprintf(stdout,"\nElément de structure n°%d |%s| de type géométrique n°%d et de dimension " IFORMAT "\n",
_i,_elementname,_geotype,_elementdim);
if ( strlen(_supportmeshname) ) {
fprintf(stdout,"\t Maillage support de nom |%s|",_supportmeshname);
if (_ncell) {
MEDmeshGeotypeName(fid,_geocelltype,_geocelltypename);
fprintf(stdout," avec " IFORMAT " maille(s) de type |%s| et",_ncell,_geocelltypename);
}
if (_nnode)
fprintf(stdout," avec " IFORMAT " noeud(s)\n",_nnode);
else {
fprintf(stderr,"\n Erreur : les noeuds doivent être définis s'il existe un maillage support\n");
}
} else
fprintf(stdout,"\t Maillage support implicite sur noeud\n");
fprintf(stdout,"\t Nombre d'attribut(s) constant(s) : " IFORMAT "",_nconstantattribute);
if (_anyprofile) fprintf(stdout,", avec profil.\n"); else fprintf(stdout,", sans profil.\n");
if ( _nconstantattribute ) {
for (_j=1;_j<=_nconstantattribute;++_j) {
_ret= MEDstructElementConstAttInfo(fid, _elementname,_j,
_constattname, &_constatttype, &_ncomponent,
&_attentitytype, _profilename, &_profilesize );
EXIT_IF(_ret < 0,"lors de la demande d'information sur les attributs constants des éléments de structure",NULL);
fprintf(stdout,"\t\t Attribut constant de nom |%s| de type %d à " IFORMAT " composantes\n",
_constattname,_constatttype,_ncomponent);
if (!_profilesize) {
if (_attentitytype == MED_NODE) _nvalue = _nnode; else _nvalue=_ncell;
} else {
_nvalue = _profilesize;
}
_n = _ncomponent*_nvalue;
if ( _constatttype == MED_ATT_NAME) ++_n;
_atttypesize = MEDstructElementAttSizeof(_constatttype);
_value = (unsigned char *) malloc(_n*_atttypesize);
if ( _constatttype == MED_ATT_NAME) --_n;
_ret= MEDstructElementConstAttRd(fid, _elementname,_constattname, _value );
if (_ret < 0 ) free(_value);
EXIT_IF(_ret < 0,"lors de la lecture des valeurs des attributs constants",NULL);
_printf=MEDstructPrintFunction(_constatttype);
if (!structure) {
fprintf(stdout,"\t\t - Valeurs de l'attribut sur les d'entité |%s|",
MED23MESH_GET_ENTITY_TYPENAME[_attentitytype+1]);
if ( _profilesize)
fprintf(stdout," avec un profil |%s| de taille " IFORMAT ": ",_profilename,_profilesize);
else
fprintf(stdout," sans profil : ");
for (_k=0;_k<_nvalue*_ncomponent;_k++) {
/* if ( ( _ncomponent > 1 ) && !(_k % _ncomponent) ) */
if ( !(_k % _ncomponent) )
fprintf(stdout,"\n [ %5" MED_IFORMAT " ] : ", (_k/_ncomponent +1) );
_printf( (void *)( (char *)(_value) + _k*_atttypesize) );
}
printf("\n");
}
/* free memory */
free(_value);
printf("\n");
} /*fin boucle sur constatt*/
} /*fin if _nconstantattribute */
fprintf(stdout,"\t Nombre d'attribut(s) variable(s) : " IFORMAT "\n",_nvariableattribute);
if ( _nvariableattribute ) {
for (_j=1;_j<=_nvariableattribute;++_j) {
_ret = MEDstructElementVarAttInfo(fid, _elementname,_j,_varattname,&_varatttype,&_ncomponent );
EXIT_IF(_ret < 0,"lors de la lecture des valeurs des attributs variables",NULL);
fprintf(stdout,"\t\t Attribut variable de nom |%s| de type %d à " IFORMAT " composantes\n",
_varattname,_varatttype,_ncomponent);
}
}
}
return;
}
/******************************************************************************
*
* - Nom de la fonction : lecture_fonctions_interpolation
* - Description : lecture des différentes fonctions d'interpolation
* hors champs et maillages.
* - Parametres :
* - fid (IN) : ID du fichier MED.
* - lecture_en_tete_seule (IN) : mode de lecture.
*
******************************************************************************/
void lecture_fonctions_interpolation(med_idt fid,
int lecture_en_tete_seulement)
{
med_err _ret=-1;
med_int _ninterp=0;
int _interpit =0;
char _interpname[MED_NAME_SIZE+1]="";
med_geometry_type _geotype =MED_NONE;
char _geotypename[MED_SNAME_SIZE+1]="";
med_int _geodim=0,_geonnodes=0;
med_bool _cellnodes =MED_FALSE;
med_int _nbasisfunc =0;
med_int _nvariable =0;
med_int _maxdegree =0;
med_int _nmaxcoefficient =0;
int _basisfuncit =0;
int _powerit =0;
med_int _ncoefficient =0;
med_int* _power =NULL;
med_float* _coefficient =NULL;
int _coefficientit =0;
_ninterp = MEDnInterp(fid);
if (_ninterp) {
fprintf(stdout,"\n(********************************)\n");
fprintf(stdout, "(* FONCTIONS D'INTERPOLATION : *)\n");
fprintf(stdout, "(********************************)\n");
printf("\nNombre de fonctions d'interpolation : " IFORMAT "\n\n",_ninterp);
}
for ( _interpit=1; _interpit<= _ninterp; ++_interpit) {
if (MEDinterpInfo(fid,_interpit,_interpname,&_geotype,&_cellnodes,&_nbasisfunc,
&_nvariable,&_maxdegree,&_nmaxcoefficient) < 0 ) {
MESSAGE("Erreur à la demande d'information de la fonction d'interpolation n°");
ISCRUTE_int(_interpit);
_ret = -1;continue;
}
MEDmeshGeotypeName(fid,_geotype,_geotypename);
fprintf(stdout,"Fonction d'interpolation n° %d |%s| sur le type géométrique |%s|\n",
_interpit,_interpname, _geotypename);
if ( MEDmeshGeotypeParameter(fid,_geotype,&_geodim,&_geonnodes) <0 ) {
MESSAGE("Erreur à la lecture du nom associé au typegeo : "); ISCRUTE_int(_geotype);
_ret = -1;continue;
}
if ( _cellnodes ) {
if ( _nbasisfunc == _geonnodes )
fprintf(stdout,"\t Les noeuds de construction sont les noeuds de la maille de référence.\n");
else {
MESSAGE("Erreur : le nombre de noeuds de construction "\
"est différent du nombre de noeuds de la maille de référence.\n");
ISCRUTE(_nbasisfunc); ISCRUTE(_geonnodes);
_ret = -1;continue;
}
}
/* if ( _nvariable != _geodim ) { */
/* MESSAGE("Erreur : le nombre de variables "\ */
/* "est différent de la dimension de l'espace de la maille de référence.\n"); */
/* ISCRUTE(_nvariable); ISCRUTE (_geodim); */
/* _ret = -1;continue; */
/* } else */
fprintf(stdout,"\t Il y a " IFORMAT " fonctions de base avec " IFORMAT " variables\n ",_nbasisfunc,_nvariable);
fprintf(stdout,"\t Le degré maximum des fonctions de base est " IFORMAT " et possèdent au maximum " IFORMAT " coefficients\n"
,_maxdegree,_nmaxcoefficient);
_coefficient = (med_float*) calloc(sizeof(med_float),_nmaxcoefficient);
_power = (med_int*) calloc(sizeof(med_int),_nvariable*_nmaxcoefficient);
for ( _basisfuncit=1; _basisfuncit<= _nbasisfunc; ++_basisfuncit) {
if ( (_ret = MEDinterpBaseFunctionRd( fid,_interpname,_basisfuncit,&_ncoefficient,_power,_coefficient) <0) ) {
MESSAGE("Erreur à la lecture de la fonction de base n°");ISCRUTE_int(_basisfuncit);
_ret=-1;continue;
} else {
if (!structure) {
fprintf(stdout,"\n\t Tableau de coefficients de la fonctions de base n° %d :\n\t",_basisfuncit);
for ( _coefficientit=1; _coefficientit<= _ncoefficient; ++_coefficientit)
fprintf(stdout," %4f ",_coefficient[_coefficientit]);
fprintf(stdout,"\n\t Tableau de puissances de la fonctions de base n° %d :\n\t",_basisfuncit);
for ( _powerit=1; _powerit<= _nvariable*_ncoefficient; ++_powerit)
fprintf(stdout," %4" MED_IFORMAT " ",_power[_powerit]);
}
}
}
fprintf(stdout,"\n");
free(_coefficient);
free(_power);
}
return;
}
/******************************************************************************
*
* - Nom de la fonction : lecture_liens
* - Description : lecture des différents liens
* hors champs et maillages.
* - Parametres :
* - fid (IN) : ID du fichier MED.
* - lecture_en_tete_seule (IN) : mode de lecture.
*
******************************************************************************/
void lecture_liens(med_idt fid,med_bool montage,
int lecture_en_tete_seulement)
{
med_err ret=0;
char nomlien[MED_NAME_SIZE+1]="";
char *lien = NULL;
med_int nln=0,nval=0;
int i;
/* Interrogation des liens */
nln = MEDnLink(fid);
if (nln) {
fprintf(stdout,"\n(***********)\n");
fprintf(stdout, "(* LIENS : *)\n");
fprintf(stdout, "(***********)\n");
printf("\nNombre de liens : " IFORMAT "\n\n",nln);
}
for (i=1 ; i <= nln ; i++ ) {
if ( MEDlinkInfo(fid, i, nomlien, &nval) < 0) {
MESSAGE("Erreur a la demande d'information sur le lien n° : "); ISCRUTE_int(i);
ret = -1;continue;
}
printf("\t- Lien n°%i de nom |%s| et de taille " IFORMAT "\n",i,nomlien,nval);
lien = (char * ) malloc((nval+1)*sizeof(char));
EXIT_IF(lien == NULL,NULL,NULL);
if ( MEDlinkRd(fid, nomlien, lien ) < 0 ) {
MESSAGE("Erreur a la lecture du lien : ");
SSCRUTE(nomlien);SSCRUTE(lien);
ret = -1;
} else {
lien[nval] = '\0'; /*On s'assure qu'il y a un terminateur de chaîne */
printf("\t\t|%s|\n\n",lien);
/*Si le montage des liens est demandé : montage les liens */
if (montage)
if (( FIDS.array[FIDS.n++]=MEDfileObjectsMount(fid, lien,MED_MESH)) < 0 ) {
printf("Erreur au montage du lien : |%s|\n",lien);
FIDS.array[FIDS.n--]=0;
ret=-1;
}
}
free(lien);
}
return;
}
/******************************************************************************
*
* - Nom de la fonction : lecture_localisation
* - Description : lecture des différentes localisations
* hors champs et maillages.
* - Parametres :
* - fid (IN) : ID du fichier MED.
* - mode_coo (IN) : mode de stockage en memoire :
* MED_FULL_INTERLACE |
* MED_NO_INTERLACE.
* - lecture_en_tete_seule (IN) : mode de lecture.
*
******************************************************************************/
void lecture_localisation(med_idt fid,
const med_switch_mode mode_coo,
int lecture_en_tete_seulement)
{
med_err ret = 0;
med_int nloc=0,locsdim=0,ngauss=0;
med_geometry_type type_geo;
med_float *refcoo=NULL, *gscoo=NULL, *wg=NULL;
char locname [MED_NAME_SIZE+1]="";
char geointerpname [MED_NAME_SIZE+1]="";
char ipointstructmeshname[MED_NAME_SIZE+1]="";
med_int nsectionmeshcell = 0;
med_geometry_type sectiongeotype;
char sectiongeotypename[MED_NAME_SIZE+1]="";
med_int locentdim=0;
med_int locnnodes=0;
char _locgeotypename[MED_NAME_SIZE+1]="";
int t1=0,t2=0,t3=0;
int i=0,j=0;
/* Interrogation des localisations des points de GAUSS */
nloc = MEDnLocalization(fid);
if (nloc) {
fprintf(stdout,"\n(********************************************)\n");
fprintf(stdout, "(* LOCALISATIONS DES POINTS D'INTEGRATION : *)\n");
fprintf(stdout, "(********************************************)\n");
printf("\nNombre de localisations stockees : " IFORMAT "\n\n",nloc);
}
for (i=1 ; i <= nloc ; i++ ) {
if ( MEDlocalizationInfo(fid, i, locname, &type_geo, &locsdim, &ngauss,
geointerpname, ipointstructmeshname, &nsectionmeshcell,
&sectiongeotype) < 0) {
MESSAGE("Erreur a la demande d'information sur la localisation n° : "); ISCRUTE_int(i);
ret = -1;continue;
}
printf("\t- Loc. n°%i de nom |%s| de dimension " IFORMAT " avec " IFORMAT " pts de GAUSS \n",i,locname,locsdim,ngauss);
if ( MEDmeshGeotypeName(fid, type_geo,_locgeotypename) <0 ) {
MESSAGE("Erreur à la lecture du nom associé au typegeo : "); ISCRUTE_int(type_geo);
ret = -1;continue;
}
if ( MEDmeshGeotypeParameter(fid, type_geo,&locentdim,&locnnodes) <0 ) {
MESSAGE("Erreur à la lecture du nom associé au typegeo : "); ISCRUTE_int(type_geo);
ret = -1;continue;
}
if (strlen(ipointstructmeshname)) {
if ( MEDmeshGeotypeName(fid, sectiongeotype,sectiongeotypename) <0 ) {
MESSAGE("Erreur à la lecture du nom associé au sectiongeotype : "); ISCRUTE_int(sectiongeotype);
SSCRUTE(ipointstructmeshname);
ret = -1;continue;
}
}
t1 = locnnodes*locsdim;
t2 = ngauss*locsdim;
t3 = ngauss;
refcoo = (med_float *) malloc(sizeof(med_float)*t1 );
gscoo = (med_float *) malloc(sizeof(med_float)*t2 );
wg = (med_float *) malloc(sizeof(med_float)*t3 );
if ( MEDlocalizationRd(fid, locname, mode_coo, refcoo, gscoo, wg ) < 0) {
MESSAGE("Erreur a la lecture des valeurs de la localisation : ");
SSCRUTE(locname);
ret = -1;
} else {
if (!structure) {
printf("\t Coordonnees de l'element de reference de type |%s| :\n\t\t",_locgeotypename);
/* for (j=0;j<t1;j++) printf(" %f ",*(refcoo+j)); */
for (j=0;j<locnnodes*locsdim;j++) {
if (mode_coo == MED_FULL_INTERLACE && !(j % locsdim))
fprintf(stdout,"\n [ %5" MED_IFORMAT " ] : ", (j/locsdim + 1) );
if (mode_coo == MED_NO_INTERLACE && ! (j % locnnodes))
fprintf(stdout,"\n\n ");
fprintf(stdout," %-+9.6f ",*(refcoo+j));
}
printf("\n");
printf("\t Localisation des points de GAUSS : \n\t\t");
/* for (j=0;j<t2;j++) printf(" %f ",*(gscoo+j)); */
for (j=0;j<ngauss*locsdim;j++) {
if (mode_coo == MED_FULL_INTERLACE && !(j % locsdim))
fprintf(stdout,"\n [ %5" MED_IFORMAT " ] : ", (j/locsdim + 1) );
if (mode_coo == MED_NO_INTERLACE && ! (j % ngauss))
fprintf(stdout,"\n\n ");
fprintf(stdout," %-+9.6f ",*(gscoo+j));
}
printf("\n");
printf("\t Poids associes aux points de GAUSS :\n\t\t");
for (j=0;j<t3;j++) printf(" %f ",*(wg+j));
printf("\n");
}
if (strlen(ipointstructmeshname)) {
printf("\t Maillage support de section d'élément de structure |%s|.\n",ipointstructmeshname);
printf("\t Mailles des sections d'élément de structure de type |%s|.\n",sectiongeotypename);
printf("\t Nombre de mailles par section d'élément de structure : " IFORMAT ".\n",nsectionmeshcell);
}
if (strlen(geointerpname)) {
printf("\t Tranformation géométrique associée à la localisation |%s|.\n",geointerpname);
}
printf("\n\n");
}
free(refcoo);
free(gscoo);
free(wg);
}
return;
}
med_idt ouverture_fichier_MED(char *fichier)
{
med_idt fid;
med_err ret = 0;
med_int majeur,mineur,release;
med_bool hdfok;
med_bool medok;
/* on regarde si le fichier existe */
ret = (int) access(fichier,F_OK);
if (ret <0) { SSCRUTE(fichier);}
EXIT_IF(ret < 0,"Le fichier n'est pas accessible ou n'existe pas ",
fichier);
/* on regarde s'il s'agit d'un fichier au format HDF 5 */
ret = MEDfileCompatibility (fichier,&hdfok, &medok );
EXIT_IF(ret < 0,"Impossible de déterminer la compatibilité de format. ",
fichier);
EXIT_IF(!hdfok,"Le fichier n'est pas dans un format HDF compatible ", fichier);
EXIT_IF(!medok,"Le fichier n'est pas dans un format MED compatible ", fichier);
/* Quelle version de MED est utilise par mdump ? */
MEDlibraryNumVersion(&majeur,&mineur,&release);
fprintf(stdout,
"- Lecture du fichier à l'aide de la bibliotheque MED V" IFORMAT "." IFORMAT "." IFORMAT " \n",
majeur,mineur,release);
/* Ouverture du fichier MED en lecture seule */
/* Le mode lecture seul ne permet pas le montage de fichier distants*/
fid = MEDfileOpen(fichier,MED_ACC_RDONLY);
EXIT_IF( fid < 0,"Ouverture du du fichier ",fichier);
MEDfileNumVersionRd(fid, &majeur, &mineur, &release);
EXIT_IF(( (majeur < 2) || ( (majeur == 2) && (mineur < 2)) ), "Le fichier est antérieur à la version 2.2", NULL);
return fid;
}
void lecture_en_tete(med_idt fid,char* fichier)
{
char fichier_en_tete[MED_COMMENT_SIZE+1];
med_err ret = 0;
/* lecture de l'en-tete du fichier (optionnel) */
/* on va lire dans le fichier */
ret = MEDfileCommentRd(fid,fichier_en_tete);
/* on affiche */
if (ret >= 0)
fprintf(stdout,"- En-tete du fichier : %s \n",fichier_en_tete);
return;
}
void parametrage(med_switch_mode *mode_coo,
med_connectivity_mode *typ_con)
{
int reponse;
char _temp[256]="";
fprintf(stdout,"(*****************)\n");
fprintf(stdout,"(* PARAMETRAGE : *)\n");
fprintf(stdout,"(*****************)\n");
fprintf(stdout,"- Mode d'affichage des coordonnées des noeuds ? \n");
fprintf(stdout," 1. Mode entrelacé : taper 1 \n");
fprintf(stdout," 2. Mode non entrelacé : taper 2 \n");
reponse = 0;
do {
fprintf(stdout," Reponse : ");
if (!scanf("%d",&reponse)) fgets(_temp, 256, stdin) ;
} while (reponse != 1 && reponse != 2);
if (reponse == 1)
*mode_coo = MED_FULL_INTERLACE;
else
*mode_coo = MED_NO_INTERLACE;
fprintf(stdout,"- Connectivité des éléments ? \n");
fprintf(stdout," 1. Nodale : taper 1 \n");
fprintf(stdout," 2. Descendante : taper 2 \n");
reponse = 0;
do {
fprintf(stdout," Reponse : ");
if (!scanf("%d",&reponse)) fgets(_temp, 256, stdin) ;
} while (reponse != 1 && reponse != 2);
if (reponse == 1)
*typ_con = MED_NODAL;
else
*typ_con = MED_DESCENDING;
return;
}
void lecture_information_maillage(const med_idt fid,
const int numero,
char * nommaa,
med_int * const mdim,
med_int * const edim,
med_mesh_type * const type_maillage,
char * const maillage_description,
med_int * const nstep,
char * const dtunit,
char * const nomcoo,
char * const unicoo,
med_axis_type *const rep)
{
char nom_universel[MED_LNAME_SIZE+1];
med_err ret = 0;
med_sorting_type sortingtype;
fprintf(stdout,"\n(**********************************************************)\n");
fprintf(stdout,"(* INFORMATIONS GENERALES SUR LE MAILLAGE DE CALCUL N°%2.2d: *)\n",numero);
fprintf(stdout,"(**********************************************************)\n\n");
/* lecture du nom et de la dimension du maillage */
ret = MEDmeshInfo(fid, numero,nommaa,edim,mdim,type_maillage,maillage_description,
dtunit,&sortingtype,nstep,rep,nomcoo,unicoo);
EXIT_IF(ret < 0,"Lecture des informations sur le maillage",NULL);
/* affichage des donnees lues */
fprintf(stdout,"- Nom du maillage : <<%s>>\n",nommaa);
fprintf(stdout,"- Dimension du maillage : " IFORMAT "\n",*mdim);
if (*edim > *mdim)
fprintf(stdout,"- La dimension de l'espace est " IFORMAT " \n",*edim);
if (*type_maillage == MED_UNSTRUCTURED_MESH)
fprintf(stdout,"- Type du maillage : MED_NON_STRUCTURE \n");
else
fprintf(stdout,"- Type du maillage : MED_STRUCTURE \n");
fprintf(stdout,"- Description associee au maillage : %s\n",
maillage_description);
if ( *nstep > 1 )
fprintf(stdout,"- Nombre d'étapes de calcul associées au maillage : " IFORMAT "\n",
*nstep);
if (strlen(dtunit))
fprintf(stdout,"- Unité des dates d'étapes de calcul associées au maillage : %s\n",
dtunit);
/* lecture du nom universel (presence optionnelle) */
ret = MEDmeshUniversalNameRd(fid,nommaa,nom_universel);
if (ret == 0)
fprintf(stdout,"- Nom universel du maillage : %s \n",nom_universel);
return;
}
/******************************************************************************
*
* - Nom de la fonction : main
* - Description : fonction "main" de l'outil de DUMP d'un fichier MED.
* - Parametres :
* - argc (IN) : nombre d'arguments sur la ligne de commande.
* - argv (IN) : liste des arguments.
*
******************************************************************************/
int main (int argc, char **argv)
{
med_err ret = 0;
med_idt fid;
int i=0,numero=0,firstmesh=0,lastmesh=0,meshit=0;
med_switch_mode mode_coo = MED_UNDEF_INTERLACE;
med_connectivity_mode typ_con = MED_UNDEF_CONNECTIVITY_MODE;
int lecture_en_tete_seulement = 0;
med_int mdim=0,nmaa=0,nmaasup=0;
char nommaa[MED_NAME_SIZE+1];
char maillage_description[MED_COMMENT_SIZE+1];
med_mesh_type type_maillage;
med_int edim;
int decalage;
char nomcoo[3*MED_SNAME_SIZE+1]="";
char unicoo[3*MED_SNAME_SIZE+1]="";
char dtunit[MED_SNAME_SIZE+1]="";
med_int nstep=0,numdt=MED_NO_DT,numit=MED_NO_IT;
int csit=0;
med_float dt=0.0;
med_axis_type rep;
/*Gestion des paramètres de la ligne de commande*/
char *filename=NULL,*typ_con_param=NULL,*mode_coo_param=NULL;
size_t _bannerlen=0;
char _temp[MAXBANNERLEN+1]="";
char * _bannerstr=NULL;
/* Focntionnalité non encore activée.*/
med_bool _montage=MED_FALSE;
/*Modèles d'élements de structure utilisés par le maillage spécifié*/
/*Celà permet de demander les champs uniquement sur ces modèles*/
med_int _nmodels=0;
med_geometry_type *_geotype_elst = NULL;
char *_geotypename_elst = NULL;
/****************************************************************************
* TEST DU NOMBRE D'ARGUMENTS *
****************************************************************************/
structure = 0;
decalage = 0;
if (argc > 2 && strcmp(argv[1], "--structure") == 0) {
--argc;++decalage;
structure = 1;
}
/*S'il y a deux arguments nous sommes en interactif, sinon il en faut 5*/
if ( (argc != 2) && (argc != 5) ) {
/* fprintf(stderr,"Utilisation mdump [--structure] monfichier.med\n"); */
fprintf(stderr,"Utilisation mdump [--structure] monfichier.med [ NODALE|DESCENDANTE "
"NO_INTERLACE|FULL_INTERLACE|LECTURE_EN_TETE_SEULEMENT N°MAILLAGE|0 pour tous ] \n");
fprintf(stderr,
"\t--structure : Lis l'ensemble des données sans afficher les données volumineuses\n"
"\tNODALE : Scrute la connectivité nodale des maillages\n"
"\tDESCENDANTE : Scrute la connectivité descendante des maillages\n"
"\tFULL_INTERLACE : Affiche les connectivités en mode entrelacé x1y1x2y2\n"
"\tNO_INTERLACE : Affiche les connectivités en mode non entrelacé x1x2y1y2\n"
"\tLECTURE_EN_TETE_SEULEMENT : Affiche uniquement les entêtes, désactive la lecture et l'affichage des données volumineuses\n"
"\tN°MAILLAGE == i : Affiche le maillage n°i et ses champs associés\n"
"\tN°MAILLAGE == 0 : Affiche l'ensemble des maillages et leurs champs associés\n"
"\tN°MAILLAGE == -1 : Affiche l'ensemble des champs qu'ils soient associés ou non à un maillage local\n");
}
EXIT_IF( (argc != 2) && (argc != 5),"nombre de parametres incorrect\n",NULL);
/****************************************************************************
* OUVERTURE DU FICHIER EN LECTURE *
****************************************************************************/
filename = argv[1+decalage];
fid = ouverture_fichier_MED(filename);
/* ICI;_MEDobjetsOuverts(fid); */
/****************************************************************************
* QUESTIONS PRELIMINAIRES *
* 1. Mode d'affichage des coordonnees (entrelace ou non) ? *
* 2. Connectivite des elements (nodale ou descendante) ? *
***************************************************************************/
fprintf(stdout,"\n >>>>>> DUMP DU FICHIER %s >>>>>>\n",filename);
/* lecture et affichage de l'en-tete du fichier */
lecture_en_tete(fid,filename);
/* ICI;_MEDobjetsOuverts(fid); */
if (argc == 2)
parametrage(&mode_coo,&typ_con);
else {
typ_con_param=argv[2 + decalage];
/* SSCRUTE(typ_con_param); */
if (! strcmp(typ_con_param,"NODALE")) typ_con = MED_NODAL;
if (! strcmp(typ_con_param,"DESCENDANTE")) typ_con = MED_DESCENDING;
EXIT_IF( typ_con==MED_UNDEF_CONNECTIVITY_MODE,"Le paramètre de connectivité doit être soit NODALE|DESCENDANTE",NULL);
mode_coo_param=argv[3 + decalage];
/* SSCRUTE(mode_coo_param); */
if (!strcmp(mode_coo_param,"NO_INTERLACE")) mode_coo = MED_NO_INTERLACE;
if (!strcmp(mode_coo_param,"FULL_INTERLACE")) mode_coo = MED_FULL_INTERLACE;
if (!strcmp(mode_coo_param,"LECTURE_EN_TETE_SEULEMENT")) { lecture_en_tete_seulement = MED_LECTURE_ENTETE_SEULEMENT;
mode_coo = MED_FULL_INTERLACE;}
EXIT_IF( (mode_coo==MED_UNDEF_INTERLACE) ,
"Le paramètre d'entrelacement doit être soit "
"NO_INTERLACE|FULL_INTERLACE|LECTURE_EN_TETE_SEULEMENT",NULL);
}
/****************************************************************************
* LIENS *
****************************************************************************/
/*On s'informe sur les liens avant de vérifier les paramètres de la ligne de commande
afin de proposer le montage des maillages distants et de les comptabiliser dans les maillages disponibles */
/* Cette option n'est pas encore activée */
lecture_liens(fid, _montage, lecture_en_tete_seulement);
/* _MEDobjetsOuverts(fid); */
/****************************************************************************
* QUEL MAILLAGE LIRE ? *
***************************************************************************/
nmaa = MEDnMesh(fid);
/* ICI;_MEDobjetsOuverts(fid); */
/* Quel maillage lire ? */
if (argc == 2) {
if (nmaa >0) {
fprintf(stdout,"- Il y a " IFORMAT " maillage(s) de type local dans ce fichier \n",nmaa);
fprintf(stdout," Lequel voulez-vous lire (0 pour tous|1|2|3|...|n) ?\n");
do {
fprintf(stdout," Reponse : ");
if (!scanf("%d",&numero)) fgets(_temp, 256, stdin) ;
} while ( (numero > nmaa) || (numero < -1) );
} else {
fprintf(stdout,"- Il n'y a pas de maillage local dans ce fichier \n");
}
} else {
if ( argc == 5 ) {
numero = atoi(argv[4 + decalage]);
EXIT_IF(numero > nmaa || numero < -1,"ce numero de maillage n'existe pas", NULL);
}
}
/****************************************************************************
* MAILLAGES SUPPORTS *
****************************************************************************/
nmaasup= MEDnSupportMesh(fid);
if (nmaasup ) {
fprintf(stdout, "\n(*****************************************************)\n");
fprintf(stdout, "(* INFORMATIONS GENERALES SUR LES MAILLAGES SUPPORT: *)\n");
fprintf(stdout, "(*****************************************************)\n");
}
for (meshit=1;meshit <= nmaasup;++meshit) {
MEDsupportMeshInfo(fid, meshit, nommaa, &edim, &mdim,
maillage_description, &rep, nomcoo, unicoo);
fprintf(stdout,"\n(*******************************************)\n");
fprintf(stdout,"(******** Maillage support n°%2.2d/%2.2" MED_IFORMAT " : *******)\n",meshit,nmaasup);
fprintf(stdout,"(*******************************************)\n");
fprintf(stdout,"- Nom du maillage support : <<%s>>\n",nommaa);
fprintf(stdout,"- Dimension du maillage : " IFORMAT "\n",mdim);
if (edim > mdim)
fprintf(stdout,"- La dimension de l'espace est " IFORMAT " \n",edim);
lecture_maillage_non_structure(fid,nommaa,MED_NO_DT,MED_NO_IT,mdim,edim,mode_coo,typ_con,
nomcoo,unicoo,&rep, &_nmodels, &_geotype_elst,&_geotypename_elst,
MED_LECTURE_MAILLAGE_SUPPORT_UNIQUEMENT);
}
/****************************************************************************
* PARAMETRES SCALAIRES *
****************************************************************************/
/* on va lire l'ensemble des parametres scalaire */
lecture_parametres_scalaires(fid,lecture_en_tete_seulement);
/* _MEDobjetsOuverts(fid); */
/****************************************************************************
* LOCALISATIONS *
****************************************************************************/
lecture_localisation(fid,mode_coo,lecture_en_tete_seulement);
/* _MEDobjetsOuverts(fid); */
/****************************************************************************
* PROFILS *
****************************************************************************/
lecture_profils(fid,lecture_en_tete_seulement);
/* _MEDobjetsOuverts(fid); */
/****************************************************************************
* MODELES D'ELEMENT DE STRUCTURE *
****************************************************************************/
lecture_modeles_elstruct( fid, lecture_en_tete_seulement);
/* _MEDobjetsOuverts(fid); */
/****************************************************************************
* FONCTIONS D'INTERPOLATION *
****************************************************************************/
lecture_fonctions_interpolation( fid, lecture_en_tete_seulement);
/* _MEDobjetsOuverts(fid); */
/**********************************************************************************
* INFOS GENERALES SUR LE MAILLAGE, PUIS MAILLAGE+CHAMPS SUR CE MAILLAGE *
***********************************************************************************/
if (numero > 0) {
firstmesh=numero;lastmesh=numero;
} else if (numero == 0) {
firstmesh=1;lastmesh=nmaa;
} else {
firstmesh = nmaa +1;
}
for (meshit=firstmesh;meshit<=lastmesh;++meshit) {
lecture_information_maillage(fid,meshit,nommaa,&mdim,&edim,&type_maillage,
maillage_description,&nstep,dtunit,nomcoo,unicoo,&rep);
/* _MEDobjetsOuverts(fid); */
if ( nstep == 0 ) {
fprintf(stderr,"Warning : Ce maillage n'a aucune étape de calcul, ceci est anormal..."
"\n\t Recherche des champs résultats associés à ce maillage.\n");
csit=0;}
else csit =1;
for (; csit <= nstep; ++csit) {
if (csit) {
ret = MEDmeshComputationStepInfo(fid, nommaa, csit, &numdt, &numit, &dt);
EXIT_IF(ret < 0,"lors de l'appel à MEDmeshComputationStepInfo",NULL);
/* fprintf(stdout,"\n(*********************************************************************************)\n"); */
/* fprintf(stdout, "(* MAILLAGE DE CALCUL |%s| N°%2.2d À L'ÉTAPE DE CALCUL (n°dt,n°it)=" */
/* "(% 2.2"MED_IFORMAT",% 2.2"MED_IFORMAT"): *)\n",nommaa,meshit,numdt,numit); */
/* fprintf(stdout, "(*********************************************************************************)\n\n"); */
/*les caractères ° sont comptabilisés comme deux caractères en locale "C" ? */
_bannerstr ="(* MAILLAGE DE CALCUL |%s| n°%2.2d A L'ETAPE DE CALCUL (n°dt,n°it)="
"(% 2.2" MED_IFORMAT ",% 2.2" MED_IFORMAT "): %.*s*)\n";
snprintf(_temp,MAXBANNERLEN+1,_bannerstr,nommaa,meshit,numdt,numit,0,"");
_bannerlen =strlen(_temp);
fprintf(stdout,"\n(");
for (i=0;i< _bannerlen-6; i++) fprintf(stdout,"*");
fprintf(stdout,")\n%s(",_temp);
for (i=0;i< _bannerlen-6; i++) fprintf(stdout,"*");
fprintf(stdout,")\n");
/****************************************************************************
* LECTURE DU MAILLAGE ET DES RESULTATS ASSOCIES *
****************************************************************************/
/* _MEDobjetsOuverts(fid); */
if (type_maillage == MED_UNSTRUCTURED_MESH)
lecture_maillage_non_structure(fid,nommaa,numdt,numit,mdim,edim,mode_coo,typ_con,
nomcoo,unicoo,&rep,
&_nmodels,&_geotype_elst,&_geotypename_elst,
lecture_en_tete_seulement);
else {
lecture_maillage_structure(fid,nommaa,numdt,numit,mdim,edim,mode_coo,
nomcoo,unicoo,lecture_en_tete_seulement);
}
/* _MEDobjetsOuverts(fid); */
}
/* on lit ensuite les resultats associes au
maillage selectionné à une étape de calcul de maillage donnée */
lecture_resultats(fid,nommaa,numdt,numit,mode_coo,
_nmodels,_geotype_elst,_geotypename_elst,
lecture_en_tete_seulement);
free(_geotype_elst);
free(_geotypename_elst);
}
}
/****************************************************************************
* LECTURE DES CHAMPS RESULTATS QLQ SOIENT LES MAILLAGES *
****************************************************************************/
if (numero == -1) {
lecture_resultats(fid,"",numdt,numit,mode_coo,
_nmodels,_geotype_elst,_geotypename_elst,
lecture_en_tete_seulement);
free(_geotype_elst);
free(_geotypename_elst);
}
/****************************************************************************
* FERMETURE DU FICHIER *
****************************************************************************/
for (i=1;i < FIDS.n ; ++i)
if ( MEDfileObjectsUnmount(fid, FIDS.array[i], MED_MESH) < 0 ) {
printf("Erreur de démontage du fichier n°%d\n",i);
}
ret = MEDfileClose(fid);
EXIT_IF(ret < 0,"lors de la fermeture du fichier",argv[1 + decalage]);
fprintf(stdout,"\n >>>>>> FIN DU DUMP DU FICHIER %s >>>>>>\n",argv[1 + decalage]);
return EXIT_SUCCESS;
}
MED23FIELD_GET_ENTITY_TYPE
med_entity_type MED23FIELD_GET_ENTITY_TYPE[MED_N_ENTITY_TYPES+2]
Definition: MED23fieldIterators.c:22
lecture_noeuds_maillage_structure
void lecture_noeuds_maillage_structure(const med_idt fid, const char *const nommaa, const med_int numdt, const med_int numit, const med_int mdim, const med_int edim, const med_int *const nind, const med_int nnoe, const char *const comp, const char *const unit, const med_grid_type type, const med_switch_mode mode_coo)
Definition: mdump4.c:1965
MEDlinkInfo
MEDC_EXPORT med_err MEDlinkInfo(const med_idt fid, const int linkit, char *const meshname, med_int *const linksize)
Cette routine permet de lire les informations sur un lien dans un fichier MED.
Definition: MEDlinkInfo.c:38
MED_FULL_INTERLACE
Definition: med.h:96
MEDmeshGeotypeName
MEDC_EXPORT med_err MEDmeshGeotypeName(const med_idt fid, const med_geometry_type geotype, char *const geotypename)
Cette routine renvoie le nom associé à un type géométrique.
Definition: MEDmeshGeotypeName.c:35
MAXBANNERLEN
#define MAXBANNERLEN
Definition: mdump4.c:147
FIDS_t::array
med_idt array[MDUMP_MAX_FILE_OPEN]
Definition: mdump3.c:118
ouverture_fichier_MED
med_idt ouverture_fichier_MED(char *fichier)
Definition: mdump4.c:3386
MEDnFamily23Attribute
MEDC_EXPORT med_int MEDnFamily23Attribute(const med_idt fid, const char *const meshname, const int famit)
Cette routine permet de lire le nombre d'attribut dans une famille dans un maillage créé avec MED 2....
Definition: MEDnFamily23Attribute.c:36
lecture_mailles_standards
void lecture_mailles_standards(const med_idt fid, const char *nommaa, const med_int numdt, const med_int numit, const med_int mdim, const med_int *const nmailles, const med_switch_mode mode_coo, const med_connectivity_mode typ_con)
Definition: mdump4.c:934
MEDnInterp
MEDC_EXPORT med_int MEDnInterp(const med_idt fid)
Cette routine renvoie le nombre d'interpolations disponibles dans le fichier.
Definition: MEDnInterp.c:34
MEDmeshPolyhedronRd
MEDC_EXPORT med_err MEDmeshPolyhedronRd(const med_idt fid, const char *const meshname, const med_int numdt, const med_int numit, const med_entity_type entitype, const med_connectivity_mode cmode, med_int *const faceindex, med_int *const nodeindex, med_int *const connectivity)
Cette routine permet la lecture dans un maillage des connectivités de polyèdres.
Definition: MEDmeshPolyhedronRd.c:45
MEDsubdomainJointInfo
MEDC_EXPORT med_err MEDsubdomainJointInfo(const med_idt fid, const char *const meshname, const int jointit, char *const jointname, char *const description, med_int *const domainnumber, char *const remotemeshname, med_int *const nstep, med_int *const nocstpncorrespondence)
Cette routine permet de lire les informations sur un joint dans un maillage.
Definition: MEDsubdomainJointInfo.c:45
lecture_nombre_faces_standards
med_int lecture_nombre_faces_standards(const med_idt fid, const char *const nommaa, const med_int numdt, const med_int numit, const med_geometry_type typ_geo, const med_int indice)
Definition: mdump4.c:1330
lecture_nombre_faces_polygones
med_int lecture_nombre_faces_polygones(const med_idt fid, const char *const nommaa, const med_int numdt, const med_int numit)
Definition: mdump4.c:1441
FIDS
FIDS_t FIDS
Definition: mdump4.c:120
lecture_mailles_polygones
void lecture_mailles_polygones(const med_idt fid, const char *const nommaa, const med_int numdt, const med_int numit, const med_geometry_type polytype, const med_int nmpolygones, const med_switch_mode mode_coo, const med_connectivity_mode typ_con)
Definition: mdump4.c:1078
MED_COMMENT_SIZE
#define MED_COMMENT_SIZE
Definition: med.h:79
lecture_maillage_structure
void lecture_maillage_structure(const med_idt fid, const char *const nommaa, const med_int numdt, const med_int numit, const med_int mdim, const med_int edim, const med_switch_mode mode_coo, const char *const comp, const char *const unit, const int lecture_en_tete_seulement)
Definition: mdump4.c:2207
med_grid_type
med_grid_type
Definition: med.h:137
MED_ALL_DT
#define MED_ALL_DT
Definition: med.h:318
MEDnProfile
MEDC_EXPORT med_int MEDnProfile(const med_idt fid)
Cette routine permet de lire le nombre de profils dans un fichier MED.
Definition: MEDnProfile.c:37
MEDfield23ValueWithProfileRd
MEDC_EXPORT med_err MEDfield23ValueWithProfileRd(const med_idt fid, const char *const fieldname, const med_int numdt, const med_int numit, const med_entity_type entitype, const med_geometry_type geotype, const char *const meshname, const med_storage_mode storagemode, const char *const profilename, const med_switch_mode switchmode, const med_int componentselect, unsigned char *const value)
Cette fonction permet de lire les valeurs d'un champ définies sur des entités d'un maillage pour une ...
Definition: MEDfield23ValueWithProfileRd.c:43
typmai
const med_geometry_type *const typmai
Definition: mdump4.c:128
MEDsupportMeshInfo
MEDC_EXPORT med_err MEDsupportMeshInfo(const med_idt fid, const int meshit, char *const supportmeshname, med_int *const spacedim, med_int *const meshdim, char *const description, med_axis_type *const axistype, char *const axisname, char *const axisunit)
Cette routine permet de lire les informations relatives à un maillage support dans un fichier.
Definition: MEDsupportMeshInfo.c:39
MEDmeshnEntity
MEDC_EXPORT med_int MEDmeshnEntity(const med_idt fid, const char *const meshname, const med_int numdt, const med_int numit, const med_entity_type entitype, const med_geometry_type geotype, const med_data_type datatype, const med_connectivity_mode cmode, med_bool *const changement, med_bool *const transformation)
Cette routine permet de lire le nombre d'entités dans un maillage pour une étape de calcul donnée.
Definition: MEDmeshnEntity.c:44
MEDmeshComputationStepInfo
MEDC_EXPORT med_err MEDmeshComputationStepInfo(const med_idt fid, const char *const meshname, const int csit, med_int *const numdt, med_int *const numit, med_float *const dt)
Cette routine permet de lire les informations relatives à une étape de calcul d'un maillage.
Definition: MEDmeshComputationStepInfo.c:38
lecture_faces_standard
void lecture_faces_standard(const med_idt fid, const char *const nommaa, const med_int numdt, const med_int numit, const med_int mdim, const med_int *const nfaces, const med_switch_mode mode_coo)
Definition: mdump4.c:1355
MEDmeshEntityNumberRd
MEDC_EXPORT med_err MEDmeshEntityNumberRd(const med_idt fid, const char *const meshname, const med_int numdt, const med_int numit, const med_entity_type entitype, const med_geometry_type geotype, med_int *const number)
Cette routine permet de lire les numéros d'un type d'entité d'un maillage.
Definition: MEDmeshEntityNumberRd.c:38
MEDnLink
MEDC_EXPORT med_int MEDnLink(const med_idt fid)
Cette routine permet la lecture du nombre de lien dans un fichier MED.
Definition: MEDnLink.c:34
MEDfileOpen
MEDC_EXPORT med_idt MEDfileOpen(const char *const filename, const med_access_mode accessmode)
Ouverture d'un fichier MED.
Definition: MEDfileOpen.c:42
med_geometry_type
int med_geometry_type
Definition: med.h:194
med_int64
int64_t med_int64
Definition: med.h:344
lecture_liens
void lecture_liens(med_idt fid, med_bool montage, int lecture_en_tete_seulement)
Definition: mdump4.c:3209
MED_SNAME_SIZE
#define MED_SNAME_SIZE
Definition: med.h:82
MED_COORDINATE_AXIS2
Definition: med.h:150
MEDnField
MEDC_EXPORT med_int MEDnField(const med_idt fid)
Cette fonction permet de lire le nombre de champs dans un fichier.
Definition: MEDnField.c:35
MED_NODAL
Definition: med.h:255
lecture_resultats
void lecture_resultats(const med_idt fid, const char *const maillage, const med_int mnumdt, const med_int mnumit, const med_switch_mode mode_coo, const med_int nmodels, const med_geometry_type *geotype_elst, const char *geotypename_elst, const int lecture_en_tete_seulement)
Definition: mdump4.c:2663
med_double
double med_double
Definition: med.h:338
MEDsubdomainComputingStepInfo
MEDC_EXPORT med_err MEDsubdomainComputingStepInfo(const med_idt fid, const char *const meshname, const char *const jointname, const int csit, med_int *const numdt, med_int *const numit, med_int *const ncorrespondence)
Cette routine permet de lire les informations sur les correspondances entre types d'entités dans un m...
Definition: MEDsubdomainComputingStepInfo.c:43
MED_N_EDGE_GEO_FIXED_CON
#define MED_N_EDGE_GEO_FIXED_CON
Definition: med.h:248
MDUMP_MAX_FILE_OPEN
#define MDUMP_MAX_FILE_OPEN
Definition: mdump4.c:113
ISCRUTE_int
#define ISCRUTE_int(entier)
Definition: med_utils.h:314
MED_NO_GEOTYPE
#define MED_NO_GEOTYPE
Definition: med.h:232
MED_DESCENDING_FACE
Definition: med.h:143
med_size
hsize_t med_size
Definition: med.h:329
med_idt
hid_t med_idt
Definition: med.h:331
MEDfieldGeometryType
MEDC_EXPORT med_err MEDfieldGeometryType(const med_idt fid, const char *const fieldname, const med_int numdt, const med_int numit, const med_entity_type entitytype, med_geometry_type *const geometrytypes, med_int *const usedbyncs)
Cette fonction retourne la liste des types géométrique présents dans un champ (med_geometry_type) pou...
Definition: MEDfieldGeometryType.c:45
MED23MESH_GET_CELL_GEOMETRY_TYPENAME
const char *const MED23MESH_GET_CELL_GEOMETRY_TYPENAME[MED_N_CELL_FIXED_GEO+2]
Definition: MED23meshIterators.c:73
typfac
const med_geometry_type *const typfac
Definition: mdump4.c:129
MED_FLOAT32
Definition: med.h:167
MED_CARTESIAN_GRID
Definition: med.h:137
MED_SEG2
#define MED_SEG2
Definition: med.h:200
nomfac
const char *const * nomfac
Definition: mdump4.c:133
MEDfamily23Info
MEDC_EXPORT med_err MEDfamily23Info(const med_idt fid, const char *const meshname, const int famit, char *const familyname, med_int *const attributenumber, med_int *const attributevalue, char *const attributedes, med_int *const familynumber, char *const groupname)
Cette routine permet de lire les informations relatives à une famille d'un maillage créé avec MED 2....
Definition: MEDfamily23Info.c:42
MED_ACC_RDONLY
Definition: med.h:120
FIDS_t
Definition: mdump3.c:116
MEDsubdomainCorrespondenceSizeInfo
MEDC_EXPORT med_err MEDsubdomainCorrespondenceSizeInfo(const med_idt fid, const char *const meshname, const char *const jointname, const med_int numdt, const med_int numit, const int corit, med_entity_type *const localentitytype, med_geometry_type *const localgeotype, med_entity_type *const remoteentitytype, med_geometry_type *const remotegeotype, med_int *const nentity)
Cette routine permet de lire les informations sur les couples d'entités en correspondance dans un joi...
Definition: MEDsubdomainCorrespondenceSizeInfo.c:48
MED23FIELD_GET_ENTITY_TYPENAME
const char *const MED23FIELD_GET_ENTITY_TYPENAME[MED_N_ENTITY_TYPES+2]
Definition: MED23fieldIterators.c:33
MED_STRUCT_ELEMENT
Definition: med.h:144
MEDmeshGeotypeParameter
MEDC_EXPORT med_err MEDmeshGeotypeParameter(const med_idt fid, const med_geometry_type geotype, med_int *const geodim, med_int *const nnodes)
Cette routine renvoie les caractéristiques d'un type géométrique de maille.
Definition: MEDmeshGeotypeParameter.c:34
med_err
herr_t med_err
Definition: med.h:332
MEDfileObjectsUnmount
MEDC_EXPORT med_err MEDfileObjectsUnmount(const med_idt fid, const med_idt mid, const med_class medclass)
Une fois le démontage effectué, les données précédemment montées ne sont plus accessibles.
Definition: MEDfileObjectsUnmount.c:33
lecture_nombre_mailles_polyedres
med_int lecture_nombre_mailles_polyedres(const med_idt fid, const char *const nommaa, const med_int numdt, const med_int numit, const med_connectivity_mode typ_con)
Definition: mdump4.c:1183
MAX
#define MAX(a, b)
Definition: mdump4.c:145
MEDfieldnGeometryType
MEDC_EXPORT med_int MEDfieldnGeometryType(const med_idt fid, const char *const fieldname, const med_int numdt, const med_int numit, const med_entity_type entitytype)
Cette fonction indique le nombre de types géométriques (med_geometry_type) présents dans le champ fie...
Definition: MEDfieldnGeometryType.c:43
MED_N_NODE_FIXED_GEO
#define MED_N_NODE_FIXED_GEO
Definition: med.h:251
med_misc.h
med_sorting_type
med_sorting_type
Definition: med.h:309
lecture_modeles_elstruct
void lecture_modeles_elstruct(med_idt fid, int lecture_en_tete_seulement)
Definition: mdump4.c:2953
MED_TRUE
Definition: med.h:260
med_entity_type
med_entity_type
Definition: med.h:143
MED_NO_CMODE
Definition: med.h:255
MED23FIELD_GET_FACE_GEOMETRY_TYPE
med_geometry_type MED23FIELD_GET_FACE_GEOMETRY_TYPE[MED_N_FACE_FIXED_GEO+2]
Definition: MED23fieldIterators.c:103
MED_INT64
Definition: med.h:169
MEDparameterValueRd
MEDC_EXPORT med_err MEDparameterValueRd(const med_idt fid, const char *const paramname, const med_int numdt, const med_int numit, unsigned char *const value)
Cette routine permet la lecture de la valeur d'un paramètre numérique scalaire.
Definition: MEDparameterValueRd.c:37
MED_FALSE
Definition: med.h:260
lecture_mailles_elstruct
void lecture_mailles_elstruct(const med_idt fid, const char *const nommaa, const med_int numdt, const med_int numit, const med_int nmodels, const med_geometry_type *const geotype, const char *const geotypename, const med_int *const nmailles, const med_switch_mode mode_coo)
Definition: mdump4.c:765
MEDmeshGridTypeRd
MEDC_EXPORT med_err MEDmeshGridTypeRd(const med_idt fid, const char *const meshname, med_grid_type *const gridtype)
Cette routine permet de lire le type d'un maillage structuré (MED_STRUCTURED_MESH).
Definition: MEDmeshGridTypeRd.c:36
MED23MESH_GET_NODE_GEOMETRY_TYPE
med_geometry_type MED23MESH_GET_NODE_GEOMETRY_TYPE[MED_N_NODE_FIXED_GEO+2]
Definition: MED23meshIterators.c:145
MED_LECTURE_ENTETE_SEULEMENT
#define MED_LECTURE_ENTETE_SEULEMENT
Definition: mdump4.c:137
MEDfieldnEntityType
MEDC_EXPORT med_int MEDfieldnEntityType(const med_idt fid, const char *const fieldname, const med_int numdt, const med_int numit)
Cette fonction indique le nombre de types d'entité présents dans un champ (med_entity_type).
Definition: MEDfieldnEntityType.c:42
MEDequivalenceCorrespondenceSize
MEDC_EXPORT med_err MEDequivalenceCorrespondenceSize(const med_idt fid, const char *const meshname, const char *const equivname, const med_int numdt, const med_int numit, const med_entity_type entitype, const med_geometry_type geotype, med_int *const nentity)
Cette routine permet de lire le nombre de correspondances dans une équivalence pour une étape de calc...
Definition: MEDequivalenceCorrespondenceSize.c:41
lecture_profils
void lecture_profils(med_idt fid, int lecture_en_tete_seulement)
Definition: mdump4.c:2900
lecture_localisation
void lecture_localisation(med_idt fid, const med_switch_mode mode_coo, int lecture_en_tete_seulement)
Definition: mdump4.c:3273
MED23FIELD_GET_EDGE_GEOMETRY_TYPENAME
const char * MED23FIELD_GET_EDGE_GEOMETRY_TYPENAME[MED_N_EDGE_FIXED_GEO+2]
Definition: MED23fieldIterators.c:137
MED23MESH_GET_EDGE_GEOMETRY_TYPENAME
const char * MED23MESH_GET_EDGE_GEOMETRY_TYPENAME[MED_N_EDGE_FIXED_GEO+2]
Definition: MED23meshIterators.c:137
MED_CELL
Definition: med.h:143
MED23MESH_GET_FACE_GEOMETRY_TYPE
med_geometry_type MED23MESH_GET_FACE_GEOMETRY_TYPE[MED_N_FACE_FIXED_GEO+2]
Definition: MED23meshIterators.c:103
lecture_faces_polygones
void lecture_faces_polygones(const med_idt fid, const char *const nommaa, const med_int numdt, const med_int numit, const med_int nfpolygones, const med_switch_mode mode_coo)
Definition: mdump4.c:1463
MEDsubdomainCorrespondenceRd
MEDC_EXPORT med_err MEDsubdomainCorrespondenceRd(const med_idt fid, const char *const meshname, const char *const jointname, const med_int numdt, const med_int numit, const med_entity_type localentitytype, const med_geometry_type localgeotype, const med_entity_type remoteentitytype, const med_geometry_type remotegeotype, med_int *const correspondence)
Cette routine permet la lecture d'une correspondance dans un joint pour un type de couple d'entité en...
Definition: MEDsubdomainCorrespondenceRd.c:46
MEDnEquivalence
MEDC_EXPORT med_int MEDnEquivalence(const med_idt fid, const char *const meshname)
Cette routine permet de lire le nombre d'équivalence dans un fichier.
Definition: MEDnEquivalence.c:36
_MEDgetInternalGeometryTypeName
MEDC_EXPORT med_err _MEDgetInternalGeometryTypeName(const med_idt fid, char *const geotypename, med_geometry_type geotype)
lecture_fonctions_interpolation
void lecture_fonctions_interpolation(med_idt fid, int lecture_en_tete_seulement)
Definition: mdump4.c:3096
MESSAGE
#define MESSAGE(chaine)
Definition: med_utils.h:324
MED_ATT_FLOAT64
Definition: med.h:173
lecture_nombre_et_type_mailles_elstruct
med_int lecture_nombre_et_type_mailles_elstruct(const med_idt fid, const char *const nommaa, const med_int numdt, const med_int numit, const int indice, med_geometry_type *geotype, char *geotypename)
Definition: mdump4.c:735
MED23MESH_GET_ENTITY_TYPE
med_entity_type MED23MESH_GET_ENTITY_TYPE[MED_N_ENTITY_TYPES+2]
Definition: MED23meshIterators.c:22
MEDmeshEntityInfo
MEDC_EXPORT med_err MEDmeshEntityInfo(const med_idt fid, const char *const meshname, const med_int numdt, const med_int numit, const med_entity_type entitype, const int geotypeit, char *const geotypename, med_geometry_type *const geotype)
Cette routine indique de façon itérative les types géométriques disponibles dans un maillage.
Definition: MEDmeshEntityInfo.c:41
MED_INT32
Definition: med.h:168
MEDmeshUniversalNameRd
MEDC_EXPORT med_err MEDmeshUniversalNameRd(const med_idt fid, const char *const meshname, char *const univname)
Cette routine permet la lecture du nom universel d'un maillage.
Definition: MEDmeshUniversalNameRd.c:38
MEDlocalizationRd
MEDC_EXPORT med_err MEDlocalizationRd(const med_idt fid, const char *const localizationname, const med_switch_mode switchmode, med_float *const elementcoordinate, med_float *const ipointcoordinate, med_float *const weight)
Cette routine permet la lecture d'une localisation localizationname de points d'intégration dans/auto...
Definition: MEDlocalizationRd.c:44
nommai
const char *const * nommai
Definition: mdump4.c:132
med_int
int med_int
Definition: med.h:342
med_field_type
med_field_type
Definition: med.h:165
lecture_nombre_noeuds_maillage_non_structure
med_int lecture_nombre_noeuds_maillage_non_structure(const med_idt fid, const char *nommaa, const med_int numdt, const med_int numit)
Definition: mdump4.c:578
MED_INT
Definition: med.h:170
MED_UNDEF_DATATYPE
Definition: med.h:152
MED_DESCENDING
Definition: med.h:255
MEDmeshGridIndexCoordinateRd
MEDC_EXPORT med_err MEDmeshGridIndexCoordinateRd(const med_idt fid, const char *const meshname, const med_int numdt, const med_int numit, const med_int axis, med_float *const gridindex)
Cette routine permet la lecture des coordonnées des noeuds d'un maillage structuré selon un axe du re...
Definition: MEDmeshGridIndexCoordinateRd.c:39
MEDfield23ComputingStepMeshInfo
MEDC_EXPORT med_err MEDfield23ComputingStepMeshInfo(const med_idt fid, const char *const fieldname, const int csit, med_int *const numdt, med_int *const numit, med_float *const dt, med_int *const nmesh, char *const meshname, med_bool *const localmesh, med_int *const meshnumdt, med_int *const meshnumit)
Cette fonction permet de lire les informations caractérisant une étape de calcul : numéro de pas de t...
Definition: MEDfield23ComputingStepMeshInfo.c:43
MEDmeshGridStructRd
MEDC_EXPORT med_err MEDmeshGridStructRd(const med_idt fid, const char *const meshname, const med_int numdt, const med_int numit, med_int *const gridstruct)
Cette routine permet la lecture de la structure (nombre de points sur chaque axe du repère) d'un mail...
Definition: MEDmeshGridStructRd.c:40
med_attribute_type
med_attribute_type
Definition: med.h:173
med_float32
float med_float32
Definition: med.h:339
MED23FIELD_GET_FACE_GEOMETRY_TYPENAME
const char *const MED23FIELD_GET_FACE_GEOMETRY_TYPENAME[MED_N_FACE_FIXED_GEO+2]
Definition: MED23fieldIterators.c:116
MEDnLocalization
MEDC_EXPORT med_int MEDnLocalization(const med_idt fid)
Cette routine permet de lire le nombre de localisations de points d'intégration contenues dans un fic...
Definition: MEDnLocalization.c:36
med.h
ISCRUTE
#define ISCRUTE(entier)
Definition: med_utils.h:313
med_bool
med_bool
Definition: med.h:260
typare
const med_geometry_type *const typare
Definition: mdump4.c:130
MED_POLYGON2
#define MED_POLYGON2
Definition: med.h:224
MEDlinkRd
MEDC_EXPORT med_err MEDlinkRd(const med_idt fid, const char *const meshname, char *const link)
Cette routine permet de lire un lien dans un fichier MED.
Definition: MEDlinkRd.c:37
MEDmeshEntityNameRd
MEDC_EXPORT med_err MEDmeshEntityNameRd(const med_idt fid, const char *const meshname, const med_int numdt, const med_int numit, const med_entity_type entitype, const med_geometry_type geotype, char *const name)
Cette routine permet de lire les noms d'un type d'entité d'un maillage.
Definition: MEDmeshEntityNameRd.c:38
MED_HEXA8
#define MED_HEXA8
Definition: med.h:213
MEDfield23nProfile
MEDC_EXPORT med_int MEDfield23nProfile(const med_idt fid, const char *const fieldname, const med_int numdt, const med_int numit, const med_entity_type entitype, const med_geometry_type geotype, const int meshit, char *const meshname, char *const defaultprofilename, char *const defaultlocalizationname)
Cette fonction permet de lire le nombre de profils référencés dans un champ pour une étape de calcul,...
Definition: MEDfield23nProfile.c:41
MDUMP_MAX_FILE_OPEN_INIT
#define MDUMP_MAX_FILE_OPEN_INIT
Definition: mdump4.c:114
MEDfieldEntityType
MEDC_EXPORT med_err MEDfieldEntityType(const med_idt fid, const char *const fieldname, const med_int numdt, const med_int numit, med_entity_type *const entitytypes, med_int *const usedbyncs)
Cette fonction retourne la liste des types d'entité présents dans un champ (med_entity_type).
Definition: MEDfieldEntityType.c:44
affs
void affs(const void *pva)
Definition: mdump4.c:164
MED_UNDEF_GRID_TYPE
Definition: med.h:140
med_float
double med_float
Definition: med.h:336
MEDnFamilyGroup
MEDC_EXPORT med_int MEDnFamilyGroup(const med_idt fid, const char *const meshname, const int famit)
Cette routine permet de lire le nombre de groupe dans une famille.
Definition: MEDnFamilyGroup.c:36
MED23FIELD_GET_NODE_GEOMETRY_TYPENAME
const char * MED23FIELD_GET_NODE_GEOMETRY_TYPENAME[MED_N_NODE_FIXED_GEO+2]
Definition: MED23fieldIterators.c:151
MED_GEO_ALL
#define MED_GEO_ALL
Definition: med.h:236
lecture_nombre_famille
med_int lecture_nombre_famille(med_idt fid, const char *const nommaa)
Definition: mdump4.c:192
lecture_mailles_polyedres
void lecture_mailles_polyedres(const med_idt fid, const char *const nommaa, const med_int numdt, const med_int numit, const med_int npolyedres, const med_switch_mode mode_coo, const med_connectivity_mode typ_con)
Definition: mdump4.c:1206
IFORMAT
#define IFORMAT
Definition: med_utils.h:145
lecture_maillage_non_structure
void lecture_maillage_non_structure(med_idt fid, const char *nommaa, const med_int numdt, const med_int numit, const med_int mdim, const med_int edim, const med_switch_mode mode_coo, const med_connectivity_mode typ_con, const char *const nomcoo, const char *const unicoo, const med_axis_type *const rep, med_int *nmodels, med_geometry_type **geotype_elst, char **geotypename_elst, const int lecture_en_tete_seulement)
Definition: mdump4.c:1679
MED_POINT1
#define MED_POINT1
Definition: med.h:198
MEDfileObjectsMount
MEDC_EXPORT med_idt MEDfileObjectsMount(const med_idt fid, const char *const filename, const med_class medclass)
Cette routine permet de monter dans le fichier courant un type de données (exemples les maillages,...
Definition: MEDfileObjectsMount.c:40
MED_IFORMAT
#define MED_IFORMAT
Definition: med_utils.h:153
lecture_mailles_maillage_structure
void lecture_mailles_maillage_structure(const med_idt fid, const char *const nommaa, const med_int numdt, const med_int numit, const med_int mdim, const med_int nmai)
Definition: mdump4.c:2114
MED_NO_DT
#define MED_NO_DT
Definition: med.h:320
MEDfileNumVersionRd
MEDC_EXPORT med_err MEDfileNumVersionRd(const med_idt fid, med_int *const major, med_int *const minor, med_int *const release)
Lecture du numéro de version de la bibliothèque MED utilisée pour créer le fichier.
Definition: MEDfileNumVersionRd.c:34
MED_NONE
#define MED_NONE
Definition: med.h:231
structure
int structure
Definition: mdump4.c:125
MED_CONNECTIVITY
Definition: med.h:149
MED23FIELD_GET_CELL_GEOMETRY_TYPENAME
const char *const MED23FIELD_GET_CELL_GEOMETRY_TYPENAME[MED_N_CELL_FIXED_GEO+2]
Definition: MED23fieldIterators.c:73
affi
void affi(const void *pva)
Definition: mdump4.c:156
getFieldsOn
med_err getFieldsOn(const med_idt fid, const char *const maillage, const med_int mnumdt, const med_int mnumit, const med_int nmodels, const med_geometry_type *const geotype_elst, const char *const geotypename_elst, const char *const nomcha, const char *const dtunit, const med_field_type typcha, const med_int ncomp, const char *const comp, const char *const unit, const med_entity_type entite, const med_switch_mode stockage, const med_int ncstp)
Definition: mdump4.c:2273
filename
#define filename
Definition: test10.c:72
MEDinterpInfo
MEDC_EXPORT med_err MEDinterpInfo(const med_idt fid, const int interpit, char *const interpname, med_geometry_type *const geotype, med_bool *const cellnode, med_int *const nbasisfunc, med_int *const nvariable, med_int *const maxdegree, med_int *const nmaxcoef)
Cette fonction informe des caractéristiques de la fonction d'interpolation n° interpit.
Definition: MEDinterpInfo.c:43
lecture_nombre_mailles_polygones
med_int lecture_nombre_mailles_polygones(const med_idt fid, const char *const nommaa, const med_int numdt, const med_int numit, const med_geometry_type polytype, const med_connectivity_mode typ_con)
Definition: mdump4.c:1045
MED_INDEX_FACE
Definition: med.h:151
MED_UNDEF_INTERLACE
Definition: med.h:100
MED_NODE
Definition: med.h:143
MEDfileCommentRd
MEDC_EXPORT med_err MEDfileCommentRd(const med_idt fid, char *const comment)
Lecture d'un descripteur dans un fichier MED.
Definition: MEDfileCommentRd.c:33
MED_N_FACE_FIXED_GEO
#define MED_N_FACE_FIXED_GEO
Definition: med.h:243
MEDlibraryNumVersion
MEDC_EXPORT med_err MEDlibraryNumVersion(med_int *const major, med_int *const minor, med_int *const release)
Renvoie les 3 numéros de version de la librairie MED.
Definition: MEDlibraryNumVersion.c:33
MEDequivalenceCorrespondenceRd
MEDC_EXPORT med_err MEDequivalenceCorrespondenceRd(const med_idt fid, const char *const meshname, const char *const equivname, const med_int numdt, const med_int numit, const med_entity_type entitype, const med_geometry_type geotype, med_int *const correspondence)
Cette routine permet de lire un tableau de correspondances entre les entités d'un maillage dans une é...
Definition: MEDequivalenceCorrespondenceRd.c:41
MEDinterpBaseFunctionRd
MEDC_EXPORT med_err MEDinterpBaseFunctionRd(const med_idt fid, const char *const interpname, const int basisfuncit, med_int *const ncoef, med_int *const power, med_float *const coefficient)
Cette routine permet la lecture d'une fonction de base/forme de l'interpolation interpname.
Definition: MEDinterpBaseFunctionRd.c:41
MEDprofileSizeByName
MEDC_EXPORT med_int MEDprofileSizeByName(const med_idt fid, const char *const profilename)
Cette routine permet de lire la taille d'un profil dont on connait le nom.
Definition: MEDprofileSizeByName.c:37
MED_MESH
Definition: med.h:188
MEDmeshNodeRd
MEDC_EXPORT med_err MEDmeshNodeRd(const med_idt fid, const char *const meshname, const med_int numdt, const med_int numit, const med_switch_mode switchmode, med_float *const coordinate, med_bool *const withnodename, char *const nodename, med_bool *const withnodenumber, med_int *const nodenumber, med_bool *const withfamnumber, med_int *const famnumber)
Cette routine permet la lecture des noeuds d'un maillage non structuré pour une étape de calcul donné...
Definition: MEDmeshNodeRd.c:43
MEDstructElementConstAttRd
MEDC_EXPORT med_err MEDstructElementConstAttRd(const med_idt fid, const char *const modelname, const char *const constattname, void *const value)
Cette routine lit la valeur d'un attribut caractéristique constant d'un modèle d'éléments de structur...
Definition: MEDstructElementConstAttRd.c:42
MEDnStructElement
MEDC_EXPORT med_int MEDnStructElement(const med_idt fid)
Cette routine renvoie le nombre de modèles d'éléments de structure.
Definition: MEDnStructElement.c:35
MED_N_CELL_FIXED_GEO
#define MED_N_CELL_FIXED_GEO
Definition: med.h:239
MED23MESH_GET_CELL_GEOMETRY_TYPE
med_geometry_type MED23MESH_GET_CELL_GEOMETRY_TYPE[MED_N_CELL_FIXED_GEO+2]
Definition: MED23meshIterators.c:44
MED_ATT_NAME
Definition: med.h:175
med_mesh_type
med_mesh_type
Definition: med.h:131
SSCRUTE
#define SSCRUTE(chaine)
Definition: med_utils.h:323
lecture_nombre_joint
med_int lecture_nombre_joint(med_idt fid, const char *const nommaa)
Definition: mdump4.c:470
MED23FIELD_GET_EDGE_GEOMETRY_TYPE
med_geometry_type MED23FIELD_GET_EDGE_GEOMETRY_TYPE[MED_N_EDGE_FIXED_GEO+2]
Definition: MED23fieldIterators.c:129
MEDlocalizationInfo
MEDC_EXPORT med_err MEDlocalizationInfo(const med_idt fid, const int localizationit, char *const localizationname, med_geometry_type *const geotype, med_int *const spacedimension, med_int *const nipoint, char *const geointerpname, char *const sectionmeshname, med_int *const nsectionmeshcell, med_geometry_type *const sectiongeotype)
Cette routine permet d'obtenir la description de la localisation de points d'intégration n° localizat...
Definition: MEDlocalizationInfo.c:46
lecture_equivalence_maillage
void lecture_equivalence_maillage(med_idt fid, const char *const nommaa, med_int nequ)
Definition: mdump4.c:300
MED_N_ENTITY_TYPES
#define MED_N_ENTITY_TYPES
Definition: med.h:146
MED23MESH_GET_ENTITY_TYPENAME
const char *const MED23MESH_GET_ENTITY_TYPENAME[MED_N_ENTITY_TYPES+2]
Definition: MED23meshIterators.c:33
_MEDgetGeometricParameter
MEDC_EXPORT med_err _MEDgetGeometricParameter(const med_entity_type entitytype, const med_geometry_type geotype, med_int *const entdim, med_int *const nnodes, med_int *const nndes)
MED23FIELD_GET_NODE_GEOMETRY_TYPE
med_geometry_type MED23FIELD_GET_NODE_GEOMETRY_TYPE[MED_N_NODE_FIXED_GEO+2]
Definition: MED23fieldIterators.c:145
MED_ERR_RANGE_MSG
#define MED_ERR_RANGE_MSG
Definition: med_err.h:61
lecture_information_maillage
void lecture_information_maillage(const med_idt fid, const int numero, char *nommaa, med_int *const mdim, med_int *const edim, med_mesh_type *const type_maillage, char *const maillage_description, med_int *const nstep, char *const dtunit, char *const nomcoo, char *const unicoo, med_axis_type *const rep)
Definition: mdump4.c:3480
MEDnParameter
MEDC_EXPORT med_int MEDnParameter(const med_idt fid)
Cette routine permet la lecture du nombre de paramètre numérique scalaire dans un fichier.
Definition: MEDnParameter.c:34
lecture_nombre_equivalence
med_int lecture_nombre_equivalence(med_idt fid, const char *const nommaa)
Definition: mdump4.c:290
lecture_famille_maillage
void lecture_famille_maillage(med_idt fid, const char *const nommaa, med_int nfam)
Definition: mdump4.c:201
MED_ATT_INT
Definition: med.h:174
USER_MODE
#define USER_MODE
Definition: mdump4.c:139
lecture_en_tete
void lecture_en_tete(med_idt fid, char *fichier)
Definition: mdump4.c:3425
MEDfield23nValueWithProfile
MEDC_EXPORT med_int MEDfield23nValueWithProfile(const med_idt fid, const char *const fieldname, const med_int numdt, const med_int numit, const med_entity_type entitype, const med_geometry_type geotype, const char *const meshname, const int profileit, const med_storage_mode storagemode, char *const profilename, med_int *const profilesize, char *const localizationname, med_int *const nintegrationpoint)
Cette fonction permet de lire le nombre de valeurs à lire dans un champ pour une étape de calcul,...
Definition: MEDfield23nValueWithProfile.c:46
MED_NAME_BLANK
#define MED_NAME_BLANK
Definition: med.h:86
_myfuncptr
void(* _myfuncptr)(const void *)
Definition: mdump4.c:170
MED_ALL_IT
#define MED_ALL_IT
Definition: med.h:319
med_switch_mode
med_switch_mode
Definition: med.h:96
MEDmeshNodeCoordinateRd
MEDC_EXPORT med_err MEDmeshNodeCoordinateRd(const med_idt fid, const char *const meshname, const med_int numdt, const med_int numit, const med_switch_mode switchmode, med_float *const coordinates)
Cette routine permet de lire dans un maillage le tableau des coordonnées des noeuds,...
Definition: MEDmeshNodeCoordinateRd.c:37
MED_LNAME_SIZE
#define MED_LNAME_SIZE
Definition: med.h:83
MED_INDEX_NODE
Definition: med.h:151
MED_NAME_SIZE
#define MED_NAME_SIZE
Definition: med.h:81
med_data_type
med_data_type
Definition: med.h:149
MEDfileCompatibility
MEDC_EXPORT med_err MEDfileCompatibility(const char *const filename, med_bool *const hdfok, med_bool *const medok)
Vérification de la compatibilité d'un fichier avec HDF et MED.
Definition: MEDfileCompatibility.c:34
MEDparameterComputationStepInfo
MEDC_EXPORT med_err MEDparameterComputationStepInfo(const med_idt fid, const char *const paramname, const int csit, med_int *const numdt, med_int *const numit, med_float *const dt)
Cette routine permet la lecture des informations relatives à une étape de calcul du paramètre numériq...
Definition: MEDparameterComputationStepInfo.c:38
lecture_aretes_standards
void lecture_aretes_standards(const med_idt fid, const char *const nommaa, const med_int numdt, const med_int numit, const med_int mdim, const med_int *const naretes, const med_switch_mode mode_coo)
Definition: mdump4.c:1577
MEDnMesh
MEDC_EXPORT med_int MEDnMesh(const med_idt fid)
Cette routine permet de lire le nombre de maillages dans un fichier.
Definition: MEDnMesh.c:34
MED23MESH_GET_FACE_GEOMETRY_TYPENAME
const char *const MED23MESH_GET_FACE_GEOMETRY_TYPENAME[MED_N_FACE_FIXED_GEO+2]
Definition: MED23meshIterators.c:116
MED_LECTURE_MAILLAGE_SUPPORT_UNIQUEMENT
#define MED_LECTURE_MAILLAGE_SUPPORT_UNIQUEMENT
Definition: mdump4.c:136
MEDmeshElementRd
MEDC_EXPORT med_err MEDmeshElementRd(const med_idt fid, const char *const meshname, const med_int numdt, const med_int numit, const med_entity_type entitype, const med_geometry_type geotype, const med_connectivity_mode cmode, const med_switch_mode switchmode, med_int *const connectivity, med_bool *const withelementname, char *const elementname, med_bool *const withelementnumber, med_int *const elementnumber, med_bool *const withfamnumber, med_int *const famnumber)
Cette routine permet la lecture d'un type d'élément d'un maillage non structuré pour une étape de cal...
Definition: MEDmeshElementRd.c:47
MED_N_CELL_GEO_FIXED_CON
#define MED_N_CELL_GEO_FIXED_CON
Definition: med.h:240
MED_UNSTRUCTURED_MESH
Definition: med.h:131
lecture_nombre_mailles_standards
med_int lecture_nombre_mailles_standards(const med_idt fid, const char *const nommaa, const med_int numdt, const med_int numit, const med_geometry_type typ_geo, const med_connectivity_mode typ_con, const int indice)
Definition: mdump4.c:710
xstr
#define xstr(s)
Definition: mdump4.c:141
MED_UNDEF_ENTITY_TYPE
Definition: med.h:145
MEDfileClose
MEDC_EXPORT med_err MEDfileClose(med_idt fid)
Fermeture d'un fichier MED.
Definition: MEDfileClose.c:30
MED_ERR_GEOMETRY_MSG
#define MED_ERR_GEOMETRY_MSG
Definition: med_err.h:158
MED_N_EDGE_FIXED_GEO
#define MED_N_EDGE_FIXED_GEO
Definition: med.h:247
med_config.h
MEDnFamily
MEDC_EXPORT med_int MEDnFamily(const med_idt fid, const char *const meshname)
Cette routine permet de lire le nombre de famille dans un maillage.
Definition: MEDnFamily.c:35
MEDequivalenceInfo
MEDC_EXPORT med_err MEDequivalenceInfo(const med_idt fid, const char *const meshname, const int equivit, char *const equivname, char *const equivdescription, med_int *const nstep, med_int *const nocstpncorrespondence)
Cette routine permet lire les informations d'une équivalence portant sur les entités d'un maillage.
Definition: MEDequivalenceInfo.c:40
MED_N_FACE_GEO_FIXED_CON
#define MED_N_FACE_GEO_FIXED_CON
Definition: med.h:244
MED_ALL_CONSTITUENT
#define MED_ALL_CONSTITUENT
Definition: med.h:299
MEDnSupportMesh
MEDC_EXPORT med_int MEDnSupportMesh(const med_idt fid)
Cette routine permet de lire le nombre de maillages support dans un fichier.
Definition: MEDnSupportMesh.c:34
MEDstructElementConstAttInfo
MEDC_EXPORT med_err MEDstructElementConstAttInfo(const med_idt fid, const char *const modelname, const int attit, char *const constattname, med_attribute_type *const constatttype, med_int *const ncomponent, med_entity_type *const sentitytype, char *const profilename, med_int *const profilesize)
Cette routine décrit les caractéristiques d'un attribut constant de modèle d'élément de structure par...
Definition: MEDstructElementConstAttInfo.c:45
nomare
const char *const * nomare
Definition: mdump4.c:134
EXIT_IF
#define EXIT_IF(expression, message, arg)
Definition: med_utils.h:343
MED_NULL
#define MED_NULL
Definition: med.h:75
affd
void affd(const void *pva)
Definition: mdump4.c:150
MED_NO_PROFILE
#define MED_NO_PROFILE
Definition: med.h:281
MED_NO_INTERLACE
Definition: med.h:98
MEDfieldInfo
MEDC_EXPORT med_err MEDfieldInfo(const med_idt fid, const int ind, char *const fieldname, char *const meshname, med_bool *const localmesh, med_field_type *const fieldtype, char *const componentname, char *const componentunit, char *const dtunit, med_int *const ncstp)
Cette fonction permet de lire les informations concernant le champ d'indice ind .
Definition: MEDfieldInfo.c:42
MEDmeshPolygonRd
MEDC_EXPORT med_err MEDmeshPolygonRd(const med_idt fid, const char *const meshname, const med_int numdt, const med_int numit, const med_entity_type entitype, const med_connectivity_mode cmode, med_int *const polyindex, med_int *const connectivity)
Cette routine permet la lecture des connectivités de polygones.
Definition: MEDmeshPolygonRd.c:44
MEDstructElementInfoByName
MEDC_EXPORT med_err MEDstructElementInfoByName(const med_idt fid, const char *const modelname, med_geometry_type *const mgeotype, med_int *const modeldim, char *const supportmeshname, med_entity_type *const sentitytype, med_int *const snnode, med_int *const sncell, med_geometry_type *const sgeotype, med_int *const nconstantatribute, med_bool *const anyprofile, med_int *const nvariableattribute)
Cette routine décrit les caractéristiques d'un modèle d'élément de structure à partir de son nom.
Definition: MEDstructElementInfoByName.c:49
lecture_noeuds_maillage_non_structure
void lecture_noeuds_maillage_non_structure(const med_idt fid, const char *const nommaa, const med_int numdt, const med_int numit, const med_int mdim, const med_int edim, const med_int nnoe, const med_switch_mode mode_coo, const char *const nomcoo, const char *const unicoo, const med_axis_type *const rep)
Definition: mdump4.c:597
med_axis_type
med_axis_type
Definition: med.h:258
lecture_caracteristiques_grille
void lecture_caracteristiques_grille(const med_idt fid, const char *const nommaa, const med_int numdt, const med_int numit, const med_int mdim, med_int *nind, med_int *nnoe, med_int *nmai, med_grid_type *type)
Definition: mdump4.c:1869
MEDparameterInfo
MEDC_EXPORT med_err MEDparameterInfo(const med_idt fid, const int paramit, char *const paramname, med_parameter_type *const paramtype, char *const description, char *const dtunit, med_int *const nstep)
Cette routine permet la lecture des informations relatives à un paramètre scalaire via un itérateur.
Definition: MEDparameterInfo.c:37
MED_FLOAT64
Definition: med.h:166
MED_CURVILINEAR_GRID
Definition: med.h:139
MEDstructElementInfo
MEDC_EXPORT med_err MEDstructElementInfo(const med_idt fid, const int mit, char *const modelname, med_geometry_type *const mgeotype, med_int *const modeldim, char *const supportmeshname, med_entity_type *const sentitytype, med_int *const snnode, med_int *const sncell, med_geometry_type *const sgeotype, med_int *const nconstantattribute, med_bool *const anyprofile, med_int *const nvariableattribute)
Cette routine décrit les caractéristiques d'un modèle d'élément de structure par itération.
Definition: MEDstructElementInfo.c:50
MEDlinkInfoByName
MEDC_EXPORT med_int MEDlinkInfoByName(const med_idt fid, const char *const meshname)
Cette routine permet de lire les informations sur un lien dans un fichier MED.
Definition: MEDlinkInfoByName.c:36
MEDstructPrintFunction
_myfuncptr MEDstructPrintFunction(med_attribute_type atttype)
Definition: mdump4.c:172
MEDmeshInfo
MEDC_EXPORT med_err MEDmeshInfo(const med_idt fid, const int meshit, char *const meshname, med_int *const spacedim, med_int *const meshdim, med_mesh_type *const meshtype, char *const description, char *const dtunit, med_sorting_type *const sortingtype, med_int *const nstep, med_axis_type *const axistype, char *const axisname, char *const axisunit)
Cette routine permet de lire les informations relatives à un maillage dans un fichier.
Definition: MEDmeshInfo.c:43
lecture_nombre_aretes_standards
med_int lecture_nombre_aretes_standards(const med_idt fid, const char *const nommaa, const med_int numdt, const med_int numit, const med_geometry_type typ_geo, const med_int indice)
Definition: mdump4.c:1554
MED_ATT_UNDEF
Definition: med.h:176
MED_NO_IT
#define MED_NO_IT
Definition: med.h:321
FIDS_t::n
int n
Definition: mdump3.c:117
med_int32
int32_t med_int32
Definition: med.h:343
parametrage
void parametrage(med_switch_mode *mode_coo, med_connectivity_mode *typ_con)
Definition: mdump4.c:3441
MED23MESH_GET_EDGE_GEOMETRY_TYPE
med_geometry_type MED23MESH_GET_EDGE_GEOMETRY_TYPE[MED_N_EDGE_FIXED_GEO+2]
Definition: MED23meshIterators.c:129
main
int main(int argc, char **argv)
Definition: mdump4.c:3542
MED_COORDINATE_AXIS3
Definition: med.h:150
MEDprofileRd
MEDC_EXPORT med_err MEDprofileRd(const med_idt fid, const char *const profilename, med_int *const profilearray)
Cette routine permet de lire un profil dans un fichier MED.
Definition: MEDprofileRd.c:39
MED_COORDINATE
Definition: med.h:149
MEDequivalenceComputingStepInfo
MEDC_EXPORT med_err MEDequivalenceComputingStepInfo(const med_idt fid, const char *const meshname, const char *const equivname, const int csit, med_int *const numdt, med_int *const numit, med_int *const ncorrespondence)
Cette routine permet de lire les informations relatives à une équivalence pour une étape de calcul do...
Definition: MEDequivalenceComputingStepInfo.c:40
MEDnSubdomainJoint
MEDC_EXPORT med_int MEDnSubdomainJoint(const med_idt fid, const char *const meshname)
Cette routine permet la lecture du nombre de joint dans un maillage.
Definition: MEDnSubdomainJoint.c:38
MEDstructElementAttSizeof
MEDC_EXPORT int MEDstructElementAttSizeof(const med_attribute_type atttype)
Cette routine renvoie la taille en octets du type élémentaire atttype.
Definition: MEDstructElementAttSizeof.c:36
MED_POLYHEDRON
#define MED_POLYHEDRON
Definition: med.h:225
MED_UNDEF_CONNECTIVITY_MODE
Definition: med.h:255
MEDfieldnComponent
MEDC_EXPORT med_int MEDfieldnComponent(const med_idt fid, const int ind)
Cette fonction lit le nombre de composantes d'un champ.
Definition: MEDfieldnComponent.c:34
MEDstructElementVarAttInfo
MEDC_EXPORT med_err MEDstructElementVarAttInfo(const med_idt fid, const char *const modelname, const int attit, char *const varattname, med_attribute_type *const varatttype, med_int *const ncomponent)
Cette routine décrit les caractéristiques d'un attribut variable de modèle d'élément de structure par...
Definition: MEDstructElementVarAttInfo.c:41
med_float64
double med_float64
Definition: med.h:337
MEDmeshEntityFamilyNumberRd
MEDC_EXPORT med_err MEDmeshEntityFamilyNumberRd(const med_idt fid, const char *const meshname, const med_int numdt, const med_int numit, const med_entity_type entitype, const med_geometry_type geotype, med_int *const number)
Cette routine permet la lecture des numéros de famille d'un type d'entité d'un maillage.
Definition: MEDmeshEntityFamilyNumberRd.c:39
MEDmeshPolygon2Rd
MEDC_EXPORT med_err MEDmeshPolygon2Rd(const med_idt fid, const char *const meshname, const med_int numdt, const med_int numit, const med_entity_type entitype, const med_geometry_type polytype, const med_connectivity_mode cmode, med_int *const polyindex, med_int *const connectivity)
Cette routine permet la lecture des connectivités de polygones.
Definition: MEDmeshPolygon2Rd.c:44
MEDprofileInfo
MEDC_EXPORT med_err MEDprofileInfo(const med_idt fid, const int profileit, char *const profilename, med_int *const profilesize)
Cette routine permet de lire les informations sur un profil dans un fichier MED.
Definition: MEDprofileInfo.c:40
med_utils.h
str
#define str(s)
Definition: mdump4.c:142
lecture_joint_maillage
void lecture_joint_maillage(med_idt fid, const char *const nommaa, med_int njnt)
Definition: mdump4.c:480
MED_COORDINATE_AXIS1
Definition: med.h:150
lecture_parametres_scalaires
void lecture_parametres_scalaires(med_idt fid, int lecture_en_tete_seulement)
Definition: mdump4.c:2808
MEDmeshStructElementVarAttRd
MEDC_EXPORT med_err MEDmeshStructElementVarAttRd(const med_idt fid, const char *const meshname, const med_int numdt, const med_int numit, const med_geometry_type mgeotype, const char *const varattname, void *const value)
Cette routine lit les valeurs d'un attribut caractéristique variable sur les éléments de structure d'...
Definition: MEDmeshStructElementVarAttRd.c:43
MED_QUAD4
#define MED_QUAD4
Definition: med.h:204
MED_POLYGON
#define MED_POLYGON
Definition: med.h:223
MED23FIELD_GET_CELL_GEOMETRY_TYPE
med_geometry_type MED23FIELD_GET_CELL_GEOMETRY_TYPE[MED_N_CELL_FIXED_GEO+2]
Definition: MED23fieldIterators.c:44
MED23MESH_GET_NODE_GEOMETRY_TYPENAME
const char * MED23MESH_GET_NODE_GEOMETRY_TYPENAME[MED_N_NODE_FIXED_GEO+2]
Definition: MED23meshIterators.c:151
med_connectivity_mode
med_connectivity_mode
Definition: med.h:255
MEDgetEntityTypeName
const char *const MEDgetEntityTypeName(med_entity_type entitytype)
Definition: MEDiterators.c:284
MED_NODE_ELEMENT
Definition: med.h:144
MED_POLAR_GRID
Definition: med.h:138
MED_DESCENDING_EDGE
Definition: med.h:143